sfc: Implement message level control
authorBen Hutchings <bhutchings@solarflare.com>
Wed, 23 Jun 2010 11:30:07 +0000 (11:30 +0000)
committerDavid S. Miller <davem@davemloft.net>
Fri, 25 Jun 2010 05:13:22 +0000 (22:13 -0700)
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>
20 files changed:
drivers/net/sfc/efx.c
drivers/net/sfc/efx.h
drivers/net/sfc/ethtool.c
drivers/net/sfc/falcon.c
drivers/net/sfc/falcon_boards.c
drivers/net/sfc/falcon_xmac.c
drivers/net/sfc/io.h
drivers/net/sfc/mcdi.c
drivers/net/sfc/mcdi_mac.c
drivers/net/sfc/mcdi_phy.c
drivers/net/sfc/mdio_10g.c
drivers/net/sfc/mdio_10g.h
drivers/net/sfc/net_driver.h
drivers/net/sfc/nic.c
drivers/net/sfc/qt202x_phy.c
drivers/net/sfc/rx.c
drivers/net/sfc/selftest.c
drivers/net/sfc/siena.c
drivers/net/sfc/tenxpress.c
drivers/net/sfc/tx.c

index 8ad476a19d95c4c4c5e35ca066ef1ca354617a4e..72514005c2a3adf87badf67eddd23a8c34d60441 100644 (file)
@@ -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;
 }
index e1e448887dfc407b8ac8f28da7e255a3f5c29328..060dc952a0fd062f93ce21642d3a8471299c86e8 100644 (file)
@@ -106,8 +106,9 @@ extern unsigned int efx_monitor_interval;
 
 static inline void efx_schedule_channel(struct efx_channel *channel)
 {
-       EFX_TRACE(channel->efx, "channel %d scheduling NAPI poll on CPU%d\n",
-                 channel->channel, raw_smp_processor_id());
+       netif_vdbg(channel->efx, intr, channel->efx->net_dev,
+                  "channel %d scheduling NAPI poll on CPU%d\n",
+                  channel->channel, raw_smp_processor_id());
        channel->work_pending = true;
 
        napi_schedule(&channel->napi_str);
index 81b7f39ca5fb9e93d8bba9b5d338579f4bf16554..27230a992893b7d6819384ea0ea01e3d5409f563 100644 (file)
@@ -218,8 +218,8 @@ int efx_ethtool_set_settings(struct net_device *net_dev,
 
        /* GMAC does not support 1000Mbps HD */
        if (ecmd->speed == SPEED_1000 && ecmd->duplex != DUPLEX_FULL) {
-               EFX_LOG(efx, "rejecting unsupported 1000Mbps HD"
-                       " setting\n");
+               netif_dbg(efx, drv, efx->net_dev,
+                         "rejecting unsupported 1000Mbps HD setting\n");
                return -EINVAL;
        }
 
@@ -256,6 +256,18 @@ static void efx_ethtool_get_regs(struct net_device *net_dev,
        efx_nic_get_regs(efx, buf);
 }
 
+static u32 efx_ethtool_get_msglevel(struct net_device *net_dev)
+{
+       struct efx_nic *efx = netdev_priv(net_dev);
+       return efx->msg_enable;
+}
+
+static void efx_ethtool_set_msglevel(struct net_device *net_dev, u32 msg_enable)
+{
+       struct efx_nic *efx = netdev_priv(net_dev);
+       efx->msg_enable = msg_enable;
+}
+
 /**
  * efx_fill_test - fill in an individual self-test entry
  * @test_index:                Index of the test
@@ -553,7 +565,8 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
        if (!already_up) {
                rc = dev_open(efx->net_dev);
                if (rc) {
-                       EFX_ERR(efx, "failed opening device.\n");
+                       netif_err(efx, drv, efx->net_dev,
+                                 "failed opening device.\n");
                        goto fail2;
                }
        }
@@ -565,9 +578,9 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
        if (!already_up)
                dev_close(efx->net_dev);
 
-       EFX_LOG(efx, "%s %sline self-tests\n",
-               rc == 0 ? "passed" : "failed",
-               (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
+       netif_dbg(efx, drv, efx->net_dev, "%s %sline self-tests\n",
+                 rc == 0 ? "passed" : "failed",
+                 (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
 
  fail2:
  fail1:
@@ -693,8 +706,8 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
                return -EOPNOTSUPP;
 
        if (coalesce->rx_coalesce_usecs || coalesce->tx_coalesce_usecs) {
-               EFX_ERR(efx, "invalid coalescing setting. "
-                       "Only rx/tx_coalesce_usecs_irq are supported\n");
+               netif_err(efx, drv, efx->net_dev, "invalid coalescing setting. "
+                         "Only rx/tx_coalesce_usecs_irq are supported\n");
                return -EOPNOTSUPP;
        }
 
@@ -706,8 +719,8 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
        efx_for_each_tx_queue(tx_queue, efx) {
                if ((tx_queue->channel->channel < efx->n_rx_channels) &&
                    tx_usecs) {
-                       EFX_ERR(efx, "Channel is shared. "
-                               "Only RX coalescing may be set\n");
+                       netif_err(efx, drv, efx->net_dev, "Channel is shared. "
+                                 "Only RX coalescing may be set\n");
                        return -EOPNOTSUPP;
                }
        }
@@ -735,13 +748,15 @@ static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
                     (pause->autoneg ? EFX_FC_AUTO : 0));
 
        if ((wanted_fc & EFX_FC_TX) && !(wanted_fc & EFX_FC_RX)) {
-               EFX_LOG(efx, "Flow control unsupported: tx ON rx OFF\n");
+               netif_dbg(efx, drv, efx->net_dev,
+                         "Flow control unsupported: tx ON rx OFF\n");
                rc = -EINVAL;
                goto out;
        }
 
        if ((wanted_fc & EFX_FC_AUTO) && !efx->link_advertising) {
-               EFX_LOG(efx, "Autonegotiation is disabled\n");
+               netif_dbg(efx, drv, efx->net_dev,
+                         "Autonegotiation is disabled\n");
                rc = -EINVAL;
                goto out;
        }
@@ -772,8 +787,9 @@ static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
            (efx->wanted_fc ^ old_fc) & EFX_FC_AUTO) {
                rc = efx->phy_op->reconfigure(efx);
                if (rc) {
-                       EFX_ERR(efx, "Unable to advertise requested flow "
-                               "control setting\n");
+                       netif_err(efx, drv, efx->net_dev,
+                                 "Unable to advertise requested flow "
+                                 "control setting\n");
                        goto out;
                }
        }
@@ -850,6 +866,8 @@ const struct ethtool_ops efx_ethtool_ops = {
        .get_drvinfo            = efx_ethtool_get_drvinfo,
        .get_regs_len           = efx_ethtool_get_regs_len,
        .get_regs               = efx_ethtool_get_regs,
+       .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_eeprom_len         = efx_ethtool_get_eeprom_len,
index 8558865ff380a1e1cf2de6a0ffde31981e21a584..92d38ede6bef31dba78beb29910f45ce96eb0630 100644 (file)
@@ -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;
        }
 
index c7a933a3292e6797b6bc55e87d8499268a63976a..92b35e3d1100d9e92c284486891bb418541daab4 100644 (file)
@@ -106,12 +106,12 @@ static int efx_check_lm87(struct efx_nic *efx, unsigned mask)
        alarms1 &= mask;
        alarms2 &= mask >> 8;
        if (alarms1 || alarms2) {
-               EFX_ERR(efx,
-                       "LM87 detected a hardware failure (status %02x:%02x)"
-                       "%s%s\n",
-                       alarms1, alarms2,
-                       (alarms1 & LM87_ALARM_TEMP_INT) ? " INTERNAL" : "",
-                       (alarms1 & LM87_ALARM_TEMP_EXT1) ? " EXTERNAL" : "");
+               netif_err(efx, hw, efx->net_dev,
+                         "LM87 detected a hardware failure (status %02x:%02x)"
+                         "%s%s\n",
+                         alarms1, alarms2,
+                         (alarms1 & LM87_ALARM_TEMP_INT) ? " INTERNAL" : "",
+                         (alarms1 & LM87_ALARM_TEMP_EXT1) ? " EXTERNAL" : "");
                return -ERANGE;
        }
 
@@ -243,7 +243,7 @@ static int sfe4001_poweron(struct efx_nic *efx)
                       (0 << P0_EN_3V3X_LBN) | (0 << P0_EN_5V_LBN) |
                       (0 << P0_EN_1V0X_LBN));
        if (rc != out) {
-               EFX_INFO(efx, "power-cycling PHY\n");
+               netif_info(efx, hw, efx->net_dev, "power-cycling PHY\n");
                rc = i2c_smbus_write_byte_data(ioexp_client, P0_OUT, out);
                if (rc)
                        goto fail_on;
@@ -269,7 +269,8 @@ static int sfe4001_poweron(struct efx_nic *efx)
                if (rc)
                        goto fail_on;
 
-               EFX_INFO(efx, "waiting for DSP boot (attempt %d)...\n", i);
+               netif_info(efx, hw, efx->net_dev,
+                          "waiting for DSP boot (attempt %d)...\n", i);
 
                /* In flash config mode, DSP does not turn on AFE, so
                 * just wait 1 second.
@@ -291,7 +292,7 @@ static int sfe4001_poweron(struct efx_nic *efx)
                }
        }
 
-       EFX_INFO(efx, "timed out waiting for DSP boot\n");
+       netif_info(efx, hw, efx->net_dev, "timed out waiting for DSP boot\n");
        rc = -ETIMEDOUT;
 fail_on:
        sfe4001_poweroff(efx);
@@ -377,7 +378,7 @@ static void sfe4001_fini(struct efx_nic *efx)
 {
        struct falcon_board *board = falcon_board(efx);
 
-       EFX_INFO(efx, "%s\n", __func__);
+       netif_info(efx, drv, efx->net_dev, "%s\n", __func__);
 
        device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg);
        sfe4001_poweroff(efx);
@@ -461,7 +462,7 @@ static int sfe4001_init(struct efx_nic *efx)
        if (rc)
                goto fail_on;
 
-       EFX_INFO(efx, "PHY is powered on\n");
+       netif_info(efx, hw, efx->net_dev, "PHY is powered on\n");
        return 0;
 
 fail_on:
@@ -493,7 +494,7 @@ static int sfn4111t_check_hw(struct efx_nic *efx)
 
 static void sfn4111t_fini(struct efx_nic *efx)
 {
-       EFX_INFO(efx, "%s\n", __func__);
+       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);
@@ -742,13 +743,14 @@ int falcon_probe_board(struct efx_nic *efx, u16 revision_info)
                        board->type = &board_types[i];
 
        if (board->type) {
-               EFX_INFO(efx, "board is %s rev %c%d\n",
+               netif_info(efx, probe, efx->net_dev, "board is %s rev %c%d\n",
                         (efx->pci_dev->subsystem_vendor == EFX_VENDID_SFC)
                         ? board->type->ref_model : board->type->gen_type,
                         'A' + board->major, board->minor);
                return 0;
        } else {
-               EFX_ERR(efx, "unknown board type %d\n", type_id);
+               netif_err(efx, probe, efx->net_dev, "unknown board type %d\n",
+                         type_id);
                return -ENODEV;
        }
 }
index c84a2ce2ccbbb905458d110172f2d272f00edf2a..bae656dd2c4ee800d161caf3d47255aca07dae40 100644 (file)
@@ -81,7 +81,8 @@ int falcon_reset_xaui(struct efx_nic *efx)
                }
                udelay(10);
        }
-       EFX_ERR(efx, "timed out waiting for XAUI/XGXS reset\n");
+       netif_err(efx, hw, efx->net_dev,
+                 "timed out waiting for XAUI/XGXS reset\n");
        return -ETIMEDOUT;
 }
 
@@ -256,7 +257,7 @@ static bool falcon_xmac_link_ok_retry(struct efx_nic *efx, int tries)
        falcon_stop_nic_stats(efx);
 
        while (!mac_up && tries) {
-               EFX_LOG(efx, "bashing xaui\n");
+               netif_dbg(efx, hw, efx->net_dev, "bashing xaui\n");
                falcon_reset_xaui(efx);
                udelay(200);
 
index 4317574c772d0a4c09ecbc12c4a5e794268c6951..85a99fe87437e409b7c946244e0d039235681988 100644 (file)
@@ -78,8 +78,9 @@ static inline void efx_writeo(struct efx_nic *efx, efx_oword_t *value,
 {
        unsigned long flags __attribute__ ((unused));
 
-       EFX_REGDUMP(efx, "writing register %x with " EFX_OWORD_FMT "\n", reg,
-                   EFX_OWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "writing register %x with " EFX_OWORD_FMT "\n", reg,
+                  EFX_OWORD_VAL(*value));
 
        spin_lock_irqsave(&efx->biu_lock, flags);
 #ifdef EFX_USE_QWORD_IO
@@ -105,8 +106,9 @@ static inline void efx_sram_writeq(struct efx_nic *efx, void __iomem *membase,
        unsigned int addr = index * sizeof(*value);
        unsigned long flags __attribute__ ((unused));
 
-       EFX_REGDUMP(efx, "writing SRAM address %x with " EFX_QWORD_FMT "\n",
-                   addr, EFX_QWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "writing SRAM address %x with " EFX_QWORD_FMT "\n",
+                  addr, EFX_QWORD_VAL(*value));
 
        spin_lock_irqsave(&efx->biu_lock, flags);
 #ifdef EFX_USE_QWORD_IO
@@ -129,8 +131,9 @@ static inline void efx_sram_writeq(struct efx_nic *efx, void __iomem *membase,
 static inline void efx_writed(struct efx_nic *efx, efx_dword_t *value,
                              unsigned int reg)
 {
-       EFX_REGDUMP(efx, "writing partial register %x with "EFX_DWORD_FMT"\n",
-                   reg, EFX_DWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "writing partial register %x with "EFX_DWORD_FMT"\n",
+                  reg, EFX_DWORD_VAL(*value));
 
        /* No lock required */
        _efx_writed(efx, value->u32[0], reg);
@@ -155,8 +158,9 @@ static inline void efx_reado(struct efx_nic *efx, efx_oword_t *value,
        value->u32[3] = _efx_readd(efx, reg + 12);
        spin_unlock_irqrestore(&efx->biu_lock, flags);
 
-       EFX_REGDUMP(efx, "read from register %x, got " EFX_OWORD_FMT "\n", reg,
-                   EFX_OWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "read from register %x, got " EFX_OWORD_FMT "\n", reg,
+                  EFX_OWORD_VAL(*value));
 }
 
 /* Read an 8-byte SRAM entry through supplied mapping,
@@ -177,8 +181,9 @@ static inline void efx_sram_readq(struct efx_nic *efx, void __iomem *membase,
 #endif
        spin_unlock_irqrestore(&efx->biu_lock, flags);
 
-       EFX_REGDUMP(efx, "read from SRAM address %x, got "EFX_QWORD_FMT"\n",
-                   addr, EFX_QWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "read from SRAM address %x, got "EFX_QWORD_FMT"\n",
+                  addr, EFX_QWORD_VAL(*value));
 }
 
 /* Read dword from register that allows partial writes (sic) */
@@ -186,8 +191,9 @@ static inline void efx_readd(struct efx_nic *efx, efx_dword_t *value,
                                unsigned int reg)
 {
        value->u32[0] = _efx_readd(efx, reg);
-       EFX_REGDUMP(efx, "read from register %x, got "EFX_DWORD_FMT"\n",
-                   reg, EFX_DWORD_VAL(*value));
+       netif_vdbg(efx, hw, efx->net_dev,
+                  "read from register %x, got "EFX_DWORD_FMT"\n",
+                  reg, EFX_DWORD_VAL(*value));
 }
 
 /* Write to a register forming part of a table */
index 93cc3c1b9450b28cb0587617855818af8de580e5..3912b8fed912d5f2bb488acc4bdccf439b0c5fe7 100644 (file)
@@ -168,11 +168,12 @@ static int efx_mcdi_poll(struct efx_nic *efx)
        error = EFX_DWORD_FIELD(reg, MCDI_HEADER_ERROR);
 
        if (error && mcdi->resplen == 0) {
-               EFX_ERR(efx, "MC rebooted\n");
+               netif_err(efx, hw, efx->net_dev, "MC rebooted\n");
                rc = EIO;
        } else if ((respseq ^ mcdi->seqno) & SEQ_MASK) {
-               EFX_ERR(efx, "MC response mismatch tx seq 0x%x rx seq 0x%x\n",
-                       respseq, mcdi->seqno);
+               netif_err(efx, hw, efx->net_dev,
+                         "MC response mismatch tx seq 0x%x rx seq 0x%x\n",
+                         respseq, mcdi->seqno);
                rc = EIO;
        } else if (error) {
                efx_readd(efx, &reg, pdu + 4);
@@ -303,8 +304,9 @@ static void efx_mcdi_ev_cpl(struct efx_nic *efx, unsigned int seqno,
                        /* The request has been cancelled */
                        --mcdi->credits;
                else
-                       EFX_ERR(efx, "MC response mismatch tx seq 0x%x rx "
-                               "seq 0x%x\n", seqno, mcdi->seqno);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "MC response mismatch tx seq 0x%x rx "
+                                 "seq 0x%x\n", seqno, mcdi->seqno);
        } else {
                mcdi->resprc = errno;
                mcdi->resplen = datalen;
@@ -352,8 +354,9 @@ int efx_mcdi_rpc(struct efx_nic *efx, unsigned cmd,
                ++mcdi->credits;
                spin_unlock_bh(&mcdi->iface_lock);
 
-               EFX_ERR(efx, "MC command 0x%x inlen %d mode %d timed out\n",
-                       cmd, (int)inlen, mcdi->mode);
+               netif_err(efx, hw, efx->net_dev,
+                         "MC command 0x%x inlen %d mode %d timed out\n",
+                         cmd, (int)inlen, mcdi->mode);
        } else {
                size_t resplen;
 
@@ -374,11 +377,13 @@ int efx_mcdi_rpc(struct efx_nic *efx, unsigned cmd,
                } else if (cmd == MC_CMD_REBOOT && rc == -EIO)
                        ; /* Don't reset if MC_CMD_REBOOT returns EIO */
                else if (rc == -EIO || rc == -EINTR) {
-                       EFX_ERR(efx, "MC fatal error %d\n", -rc);
+                       netif_err(efx, hw, efx->net_dev, "MC fatal error %d\n",
+                                 -rc);
                        efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
                } else
-                       EFX_ERR(efx, "MC command 0x%x inlen %d failed rc=%d\n",
-                               cmd, (int)inlen, -rc);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "MC command 0x%x inlen %d failed rc=%d\n",
+                                 cmd, (int)inlen, -rc);
        }
 
        efx_mcdi_release(mcdi);
@@ -534,8 +539,9 @@ static void efx_mcdi_sensor_event(struct efx_nic *efx, efx_qword_t *ev)
        EFX_BUG_ON_PARANOID(state >= ARRAY_SIZE(sensor_status_names));
        state_txt = sensor_status_names[state];
 
-       EFX_ERR(efx, "Sensor %d (%s) reports condition '%s' for raw value %d\n",
-               monitor, name, state_txt, value);
+       netif_err(efx, hw, efx->net_dev,
+                 "Sensor %d (%s) reports condition '%s' for raw value %d\n",
+                 monitor, name, state_txt, value);
 }
 
 /* Called from  falcon_process_eventq for MCDI events */
@@ -548,12 +554,13 @@ void efx_mcdi_process_event(struct efx_channel *channel,
 
        switch (code) {
        case MCDI_EVENT_CODE_BADSSERT:
-               EFX_ERR(efx, "MC watchdog or assertion failure at 0x%x\n", data);
+               netif_err(efx, hw, efx->net_dev,
+                         "MC watchdog or assertion failure at 0x%x\n", data);
                efx_mcdi_ev_death(efx, EINTR);
                break;
 
        case MCDI_EVENT_CODE_PMNOTICE:
-               EFX_INFO(efx, "MCDI PM event.\n");
+               netif_info(efx, wol, efx->net_dev, "MCDI PM event.\n");
                break;
 
        case MCDI_EVENT_CODE_CMDDONE:
@@ -570,10 +577,11 @@ void efx_mcdi_process_event(struct efx_channel *channel,
                efx_mcdi_sensor_event(efx, event);
                break;
        case MCDI_EVENT_CODE_SCHEDERR:
-               EFX_INFO(efx, "MC Scheduler error address=0x%x\n", data);
+               netif_info(efx, hw, efx->net_dev,
+                          "MC Scheduler error address=0x%x\n", data);
                break;
        case MCDI_EVENT_CODE_REBOOT:
-               EFX_INFO(efx, "MC Reboot\n");
+               netif_info(efx, hw, efx->net_dev, "MC Reboot\n");
                efx_mcdi_ev_death(efx, EIO);
                break;
        case MCDI_EVENT_CODE_MAC_STATS_DMA:
@@ -581,7 +589,8 @@ void efx_mcdi_process_event(struct efx_channel *channel,
                break;
 
        default:
-               EFX_ERR(efx, "Unknown MCDI event 0x%x\n", code);
+               netif_err(efx, hw, efx->net_dev, "Unknown MCDI event 0x%x\n",
+                         code);
        }
 }
 
@@ -627,7 +636,7 @@ int efx_mcdi_fwver(struct efx_nic *efx, u64 *version, u32 *build)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -657,7 +666,7 @@ int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -695,7 +704,8 @@ int efx_mcdi_get_board_cfg(struct efx_nic *efx, u8 *mac_address,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d len=%d\n", __func__, rc, (int)outlen);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d len=%d\n",
+                 __func__, rc, (int)outlen);
 
        return rc;
 }
@@ -724,7 +734,7 @@ int efx_mcdi_log_ctrl(struct efx_nic *efx, bool evq, bool uart, u32 dest_evq)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -749,8 +759,8 @@ int efx_mcdi_nvram_types(struct efx_nic *efx, u32 *nvram_types_out)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n",
-               __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                 __func__, rc);
        return rc;
 }
 
@@ -781,7 +791,7 @@ int efx_mcdi_nvram_info(struct efx_nic *efx, unsigned int type,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -802,7 +812,7 @@ int efx_mcdi_nvram_update_start(struct efx_nic *efx, unsigned int type)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -827,7 +837,7 @@ int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -853,7 +863,7 @@ int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -877,7 +887,7 @@ int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -898,7 +908,7 @@ int efx_mcdi_nvram_update_finish(struct efx_nic *efx, unsigned int type)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -948,9 +958,10 @@ int efx_mcdi_nvram_test_all(struct efx_nic *efx)
        return 0;
 
 fail2:
-       EFX_ERR(efx, "%s: failed type=%u\n", __func__, type);
+       netif_err(efx, hw, efx->net_dev, "%s: failed type=%u\n",
+                 __func__, type);
 fail1:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -994,14 +1005,15 @@ static int efx_mcdi_read_assertion(struct efx_nic *efx)
                : (flags == MC_CMD_GET_ASSERTS_FLAGS_WDOG_FIRED)
                ? "watchdog reset"
                : "unknown assertion";
-       EFX_ERR(efx, "MCPU %s at PC = 0x%.8x in thread 0x%.8x\n", reason,
-               MCDI_DWORD(outbuf, GET_ASSERTS_OUT_SAVED_PC_OFFS),
-               MCDI_DWORD(outbuf, GET_ASSERTS_OUT_THREAD_OFFS));
+       netif_err(efx, hw, efx->net_dev,
+                 "MCPU %s at PC = 0x%.8x in thread 0x%.8x\n", reason,
+                 MCDI_DWORD(outbuf, GET_ASSERTS_OUT_SAVED_PC_OFFS),
+                 MCDI_DWORD(outbuf, GET_ASSERTS_OUT_THREAD_OFFS));
 
        /* Print out the registers */
        ofst = MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_OFST;
        for (index = 1; index < 32; index++) {
-               EFX_ERR(efx, "R%.2d (?): 0x%.8x\n", index,
+               netif_err(efx, hw, efx->net_dev, "R%.2d (?): 0x%.8x\n", index,
                        MCDI_DWORD2(outbuf, ofst));
                ofst += sizeof(efx_dword_t);
        }
@@ -1050,14 +1062,16 @@ void efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
        rc = efx_mcdi_rpc(efx, MC_CMD_SET_ID_LED, inbuf, sizeof(inbuf),
                          NULL, 0, NULL);
        if (rc)
-               EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+               netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                         __func__, rc);
 }
 
 int efx_mcdi_reset_port(struct efx_nic *efx)
 {
        int rc = efx_mcdi_rpc(efx, MC_CMD_PORT_RESET, NULL, 0, NULL, 0, NULL);
        if (rc)
-               EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+               netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                         __func__, rc);
        return rc;
 }
 
@@ -1075,7 +1089,7 @@ int efx_mcdi_reset_mc(struct efx_nic *efx)
                return 0;
        if (rc == 0)
                rc = -EIO;
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -1108,7 +1122,7 @@ int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
 
 fail:
        *id_out = -1;
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 
 }
@@ -1143,7 +1157,7 @@ int efx_mcdi_wol_filter_get_magic(struct efx_nic *efx, int *id_out)
 
 fail:
        *id_out = -1;
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -1163,7 +1177,7 @@ int efx_mcdi_wol_filter_remove(struct efx_nic *efx, int id)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -1179,7 +1193,7 @@ int efx_mcdi_wol_filter_reset(struct efx_nic *efx)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
index 39182631ac924a3938e3cbb39e1d28073c5cca55..f88f4bf986ff423d56ea6c8507b1254dc1dfec86 100644 (file)
@@ -69,8 +69,8 @@ static int efx_mcdi_get_mac_faults(struct efx_nic *efx, u32 *faults)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n",
-               __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                 __func__, rc);
        return rc;
 }
 
@@ -110,8 +110,8 @@ int efx_mcdi_mac_stats(struct efx_nic *efx, dma_addr_t dma_addr,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: %s failed rc=%d\n",
-               __func__, enable ? "enable" : "disable", rc);
+       netif_err(efx, hw, efx->net_dev, "%s: %s failed rc=%d\n",
+                 __func__, enable ? "enable" : "disable", rc);
        return rc;
 }
 
index 86e43b1f76898b4ad69dd6905b8c7f866567455e..0121e71702bf9a5183ece1870c544f409d44b05f 100644 (file)
@@ -71,7 +71,7 @@ efx_mcdi_get_phy_cfg(struct efx_nic *efx, struct efx_mcdi_phy_data *cfg)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -97,7 +97,7 @@ static int efx_mcdi_set_link(struct efx_nic *efx, u32 capabilities,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -122,7 +122,7 @@ static int efx_mcdi_loopback_modes(struct efx_nic *efx, u64 *loopback_modes)
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -150,7 +150,7 @@ int efx_mcdi_mdio_read(struct efx_nic *efx, unsigned int bus,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -178,7 +178,7 @@ int efx_mcdi_mdio_write(struct efx_nic *efx, unsigned int bus,
        return 0;
 
 fail:
-       EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+       netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
        return rc;
 }
 
@@ -466,8 +466,8 @@ void efx_mcdi_phy_check_fcntl(struct efx_nic *efx, u32 lpa)
                rmtadv |=  ADVERTISED_Asym_Pause;
 
        if ((efx->wanted_fc & EFX_FC_TX) && rmtadv == ADVERTISED_Asym_Pause)
-               EFX_ERR(efx, "warning: link partner doesn't support "
-                       "pause frames");
+               netif_err(efx, link, efx->net_dev,
+                         "warning: link partner doesn't support pause frames");
 }
 
 static bool efx_mcdi_phy_poll(struct efx_nic *efx)
@@ -483,7 +483,8 @@ static bool efx_mcdi_phy_poll(struct efx_nic *efx)
        rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
                          outbuf, sizeof(outbuf), NULL);
        if (rc) {
-               EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+               netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                         __func__, rc);
                efx->link_state.up = false;
        } else {
                efx_mcdi_phy_decode_link(
@@ -526,7 +527,8 @@ static void efx_mcdi_phy_get_settings(struct efx_nic *efx, struct ethtool_cmd *e
        rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
                          outbuf, sizeof(outbuf), NULL);
        if (rc) {
-               EFX_ERR(efx, "%s: failed rc=%d\n", __func__, rc);
+               netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
+                         __func__, rc);
                return;
        }
        ecmd->lp_advertising =
index 0548fcbbdcd0982ec1b8d2ca9b278d935951d7bc..eeaf0bd64bd3c2873c74bb0e4664a44f478c4e8d 100644 (file)
@@ -63,7 +63,8 @@ static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd, int fault_fatal)
                /* Read MMD STATUS2 to check it is responding. */
                status = efx_mdio_read(efx, mmd, MDIO_STAT2);
                if ((status & MDIO_STAT2_DEVPRST) != MDIO_STAT2_DEVPRST_VAL) {
-                       EFX_ERR(efx, "PHY MMD %d not responding.\n", mmd);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "PHY MMD %d not responding.\n", mmd);
                        return -EIO;
                }
        }
@@ -72,12 +73,14 @@ static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd, int fault_fatal)
        status = efx_mdio_read(efx, mmd, MDIO_STAT1);
        if (status & MDIO_STAT1_FAULT) {
                if (fault_fatal) {
-                       EFX_ERR(efx, "PHY MMD %d reporting fatal"
-                               " fault: status %x\n", mmd, status);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "PHY MMD %d reporting fatal"
+                                 " fault: status %x\n", mmd, status);
                        return -EIO;
                } else {
-                       EFX_LOG(efx, "PHY MMD %d reporting status"
-                               " %x (expected)\n", mmd, status);
+                       netif_dbg(efx, hw, efx->net_dev,
+                                 "PHY MMD %d reporting status"
+                                 " %x (expected)\n", mmd, status);
                }
        }
        return 0;
@@ -103,8 +106,9 @@ int efx_mdio_wait_reset_mmds(struct efx_nic *efx, unsigned int mmd_mask)
                        if (mask & 1) {
                                stat = efx_mdio_read(efx, mmd, MDIO_CTRL1);
                                if (stat < 0) {
-                                       EFX_ERR(efx, "failed to read status of"
-                                               " MMD %d\n", mmd);
+                                       netif_err(efx, hw, efx->net_dev,
+                                                 "failed to read status of"
+                                                 " MMD %d\n", mmd);
                                        return -EIO;
                                }
                                if (stat & MDIO_CTRL1_RESET)
@@ -119,8 +123,9 @@ int efx_mdio_wait_reset_mmds(struct efx_nic *efx, unsigned int mmd_mask)
                msleep(spintime);
        }
        if (in_reset != 0) {
-               EFX_ERR(efx, "not all MMDs came out of reset in time."
-                       " MMDs still in reset: %x\n", in_reset);
+               netif_err(efx, hw, efx->net_dev,
+                         "not all MMDs came out of reset in time."
+                         " MMDs still in reset: %x\n", in_reset);
                rc = -ETIMEDOUT;
        }
        return rc;
@@ -142,16 +147,18 @@ int efx_mdio_check_mmds(struct efx_nic *efx,
        devs1 = efx_mdio_read(efx, probe_mmd, MDIO_DEVS1);
        devs2 = efx_mdio_read(efx, probe_mmd, MDIO_DEVS2);
        if (devs1 < 0 || devs2 < 0) {
-               EFX_ERR(efx, "failed to read devices present\n");
+               netif_err(efx, hw, efx->net_dev,
+                         "failed to read devices present\n");
                return -EIO;
        }
        devices = devs1 | (devs2 << 16);
        if ((devices & mmd_mask) != mmd_mask) {
-               EFX_ERR(efx, "required MMDs not present: got %x, "
-                       "wanted %x\n", devices, mmd_mask);
+               netif_err(efx, hw, efx->net_dev,
+                         "required MMDs not present: got %x, wanted %x\n",
+                         devices, mmd_mask);
                return -ENODEV;
        }
-       EFX_TRACE(efx, "Devices present: %x\n", devices);
+       netif_vdbg(efx, hw, efx->net_dev, "Devices present: %x\n", devices);
 
        /* Check all required MMDs are responding and happy. */
        while (mmd_mask) {
@@ -219,7 +226,7 @@ static void efx_mdio_set_mmd_lpower(struct efx_nic *efx,
 {
        int stat = efx_mdio_read(efx, mmd, MDIO_STAT1);
 
-       EFX_TRACE(efx, "Setting low power mode for MMD %d to %d\n",
+       netif_vdbg(efx, drv, efx->net_dev, "Setting low power mode for MMD %d to %d\n",
                  mmd, lpower);
 
        if (stat & MDIO_STAT1_LPOWERABLE) {
@@ -349,8 +356,8 @@ int efx_mdio_test_alive(struct efx_nic *efx)
 
        if ((physid1 == 0x0000) || (physid1 == 0xffff) ||
            (physid2 == 0x0000) || (physid2 == 0xffff)) {
-               EFX_ERR(efx, "no MDIO PHY present with ID %d\n",
-                       efx->mdio.prtad);
+               netif_err(efx, hw, efx->net_dev,
+                         "no MDIO PHY present with ID %d\n", efx->mdio.prtad);
                rc = -EINVAL;
        } else {
                rc = efx_mdio_check_mmds(efx, efx->mdio.mmds, 0);
index f89e719296031194a6953eba58daebe66b08164b..75791d3d4963f0a1a445c1fc269b938bd3499ccb 100644 (file)
@@ -51,7 +51,8 @@ static inline bool efx_mdio_phyxgxs_lane_sync(struct efx_nic *efx)
 
        sync = !!(lane_status & MDIO_PHYXS_LNSTAT_ALIGN);
        if (!sync)
-               EFX_LOG(efx, "XGXS lane status: %x\n", lane_status);
+               netif_dbg(efx, hw, efx->net_dev, "XGXS lane status: %x\n",
+                         lane_status);
        return sync;
 }
 
index ba636e086fc39598964143e2fd8e68428112bb20..0cca44b4ee449be2306fc81461a38ceee2501eaa 100644 (file)
 #ifndef EFX_NET_DRIVER_H
 #define EFX_NET_DRIVER_H
 
+#if defined(EFX_ENABLE_DEBUG) && !defined(DEBUG)
+#define DEBUG
+#endif
+
 #include <linux/version.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #define EFX_WARN_ON_PARANOID(x) do {} while (0)
 #endif
 
-/* Un-rate-limited logging */
-#define EFX_ERR(efx, fmt, args...) \
-dev_err(&((efx)->pci_dev->dev), "ERR: %s " fmt, efx_dev_name(efx), ##args)
-
-#define EFX_INFO(efx, fmt, args...) \
-dev_info(&((efx)->pci_dev->dev), "INFO: %s " fmt, efx_dev_name(efx), ##args)
-
-#ifdef EFX_ENABLE_DEBUG
-#define EFX_LOG(efx, fmt, args...) \
-dev_info(&((efx)->pci_dev->dev), "DBG: %s " fmt, efx_dev_name(efx), ##args)
-#else
-#define EFX_LOG(efx, fmt, args...) \
-dev_dbg(&((efx)->pci_dev->dev), "DBG: %s " fmt, efx_dev_name(efx), ##args)
-#endif
-
-#define EFX_TRACE(efx, fmt, args...) do {} while (0)
-
-#define EFX_REGDUMP(efx, fmt, args...) do {} while (0)
-
-/* Rate-limited logging */
-#define EFX_ERR_RL(efx, fmt, args...) \
-do {if (net_ratelimit()) EFX_ERR(efx, fmt, ##args); } while (0)
-
-#define EFX_INFO_RL(efx, fmt, args...) \
-do {if (net_ratelimit()) EFX_INFO(efx, fmt, ##args); } while (0)
-
-#define EFX_LOG_RL(efx, fmt, args...) \
-do {if (net_ratelimit()) EFX_LOG(efx, fmt, ##args); } while (0)
-
 /**************************************************************************
  *
  * Efx data structures
@@ -663,6 +638,7 @@ union efx_multicast_hash {
  * @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
+ * @msg_enable: Log message enable flags
  * @state: Device state flag. Serialised by the rtnl_lock.
  * @reset_pending: Pending reset method (normally RESET_TYPE_NONE)
  * @tx_queue: TX DMA queues
@@ -746,6 +722,7 @@ struct efx_nic {
        enum efx_int_mode interrupt_mode;
        bool irq_rx_adaptive;
        unsigned int irq_rx_moderation;
+       u32 msg_enable;
 
        enum nic_state state;
        enum reset_type reset_pending;
index 67235f1c25503bf3a824ec1818c593b83d80350a..30836578c1cc92b31dc7fc244f7605c63c28c159 100644 (file)
@@ -179,9 +179,10 @@ int efx_nic_test_registers(struct efx_nic *efx,
        return 0;
 
 fail:
-       EFX_ERR(efx, "wrote "EFX_OWORD_FMT" read "EFX_OWORD_FMT
-               " at address 0x%x mask "EFX_OWORD_FMT"\n", EFX_OWORD_VAL(reg),
-               EFX_OWORD_VAL(buf), address, EFX_OWORD_VAL(mask));
+       netif_err(efx, hw, efx->net_dev,
+                 "wrote "EFX_OWORD_FMT" read "EFX_OWORD_FMT
+                 " at address 0x%x mask "EFX_OWORD_FMT"\n", EFX_OWORD_VAL(reg),
+                 EFX_OWORD_VAL(buf), address, EFX_OWORD_VAL(mask));
        return -EIO;
 }
 
@@ -214,8 +215,9 @@ efx_init_special_buffer(struct efx_nic *efx, struct efx_special_buffer *buffer)
        for (i = 0; i < buffer->entries; i++) {
                index = buffer->index + i;
                dma_addr = buffer->dma_addr + (i * 4096);
-               EFX_LOG(efx, "mapping special buffer %d at %llx\n",
-                       index, (unsigned long long)dma_addr);
+               netif_dbg(efx, probe, efx->net_dev,
+                         "mapping special buffer %d at %llx\n",
+                         index, (unsigned long long)dma_addr);
                EFX_POPULATE_QWORD_3(buf_desc,
                                     FRF_AZ_BUF_ADR_REGION, 0,
                                     FRF_AZ_BUF_ADR_FBUF, dma_addr >> 12,
@@ -235,8 +237,8 @@ efx_fini_special_buffer(struct efx_nic *efx, struct efx_special_buffer *buffer)
        if (!buffer->entries)
                return;
 
-       EFX_LOG(efx, "unmapping special buffers %d-%d\n",
-               buffer->index, buffer->index + buffer->entries - 1);
+       netif_dbg(efx, hw, efx->net_dev, "unmapping special buffers %d-%d\n",
+                 buffer->index, buffer->index + buffer->entries - 1);
 
        EFX_POPULATE_OWORD_4(buf_tbl_upd,
                             FRF_AZ_BUF_UPD_CMD, 0,
@@ -276,11 +278,12 @@ static int efx_alloc_special_buffer(struct efx_nic *efx,
        buffer->index = efx->next_buffer_table;
        efx->next_buffer_table += buffer->entries;
 
-       EFX_LOG(efx, "allocating special buffers %d-%d at %llx+%x "
-               "(virt %p phys %llx)\n", buffer->index,
-               buffer->index + buffer->entries - 1,
-               (u64)buffer->dma_addr, len,
-               buffer->addr, (u64)virt_to_phys(buffer->addr));
+       netif_dbg(efx, probe, efx->net_dev,
+                 "allocating special buffers %d-%d at %llx+%x "
+                 "(virt %p phys %llx)\n", buffer->index,
+                 buffer->index + buffer->entries - 1,
+                 (u64)buffer->dma_addr, len,
+                 buffer->addr, (u64)virt_to_phys(buffer->addr));
 
        return 0;
 }
@@ -291,11 +294,12 @@ efx_free_special_buffer(struct efx_nic *efx, struct efx_special_buffer *buffer)
        if (!buffer->addr)
                return;
 
-       EFX_LOG(efx, "deallocating special buffers %d-%d at %llx+%x "
-               "(virt %p phys %llx)\n", buffer->index,
-               buffer->index + buffer->entries - 1,
-               (u64)buffer->dma_addr, buffer->len,
-               buffer->addr, (u64)virt_to_phys(buffer->addr));
+       netif_dbg(efx, hw, efx->net_dev,
+                 "deallocating special buffers %d-%d at %llx+%x "
+                 "(virt %p phys %llx)\n", buffer->index,
+                 buffer->index + buffer->entries - 1,
+                 (u64)buffer->dma_addr, buffer->len,
+                 buffer->addr, (u64)virt_to_phys(buffer->addr));
 
        pci_free_consistent(efx->pci_dev, buffer->len, buffer->addr,
                            buffer->dma_addr);
@@ -555,9 +559,10 @@ void efx_nic_init_rx(struct efx_rx_queue *rx_queue)
        bool is_b0 = efx_nic_rev(efx) >= EFX_REV_FALCON_B0;
        bool iscsi_digest_en = is_b0;
 
-       EFX_LOG(efx, "RX queue %d ring in special buffers %d-%d\n",
-               rx_queue->queue, rx_queue->rxd.index,
-               rx_queue->rxd.index + rx_queue->rxd.entries - 1);
+       netif_dbg(efx, hw, efx->net_dev,
+                 "RX queue %d ring in special buffers %d-%d\n",
+                 rx_queue->queue, rx_queue->rxd.index,
+                 rx_queue->rxd.index + rx_queue->rxd.entries - 1);
 
        rx_queue->flushed = FLUSH_NONE;
 
@@ -694,9 +699,10 @@ efx_handle_tx_event(struct efx_channel *channel, efx_qword_t *event)
                   EFX_WORKAROUND_10727(efx)) {
                efx_schedule_reset(efx, RESET_TYPE_TX_DESC_FETCH);
        } else {
-               EFX_ERR(efx, "channel %d unexpected TX event "
-                       EFX_QWORD_FMT"\n", channel->channel,
-                       EFX_QWORD_VAL(*event));
+               netif_err(efx, tx_err, efx->net_dev,
+                         "channel %d unexpected TX event "
+                         EFX_QWORD_FMT"\n", channel->channel,
+                         EFX_QWORD_VAL(*event));
        }
 
        return tx_packets;
@@ -759,20 +765,21 @@ static void efx_handle_rx_not_ok(struct efx_rx_queue *rx_queue,
         * to a FIFO overflow.
         */
 #ifdef EFX_ENABLE_DEBUG
-       if (rx_ev_other_err) {
-               EFX_INFO_RL(efx, " 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),
-                           rx_ev_buf_owner_id_err ? " [OWNER_ID_ERR]" : "",
-                           rx_ev_ip_hdr_chksum_err ?
-                           " [IP_HDR_CHKSUM_ERR]" : "",
-                           rx_ev_tcp_udp_chksum_err ?
-                           " [TCP_UDP_CHKSUM_ERR]" : "",
-                           rx_ev_eth_crc_err ? " [ETH_CRC_ERR]" : "",
-                           rx_ev_frm_trunc ? " [FRM_TRUNC]" : "",
-                           rx_ev_drib_nib ? " [DRIB_NIB]" : "",
-                           rx_ev_tobe_disc ? " [TOBE_DISC]" : "",
-                           rx_ev_pause_frm ? " [PAUSE]" : "");
+       if (rx_ev_other_err && net_ratelimit()) {
+               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),
+                         rx_ev_buf_owner_id_err ? " [OWNER_ID_ERR]" : "",
+                         rx_ev_ip_hdr_chksum_err ?
+                         " [IP_HDR_CHKSUM_ERR]" : "",
+                         rx_ev_tcp_udp_chksum_err ?
+                         " [TCP_UDP_CHKSUM_ERR]" : "",
+                         rx_ev_eth_crc_err ? " [ETH_CRC_ERR]" : "",
+                         rx_ev_frm_trunc ? " [FRM_TRUNC]" : "",
+                         rx_ev_drib_nib ? " [DRIB_NIB]" : "",
+                         rx_ev_tobe_disc ? " [TOBE_DISC]" : "",
+                         rx_ev_pause_frm ? " [PAUSE]" : "");
        }
 #endif
 }
@@ -786,8 +793,9 @@ efx_handle_rx_bad_index(struct efx_rx_queue *rx_queue, unsigned index)
 
        expected = rx_queue->removed_count & EFX_RXQ_MASK;
        dropped = (index - expected) & EFX_RXQ_MASK;
-       EFX_INFO(efx, "dropped %d events (index=%d expected=%d)\n",
-               dropped, index, expected);
+       netif_info(efx, rx_err, efx->net_dev,
+                  "dropped %d events (index=%d expected=%d)\n",
+                  dropped, index, expected);
 
        efx_schedule_reset(efx, EFX_WORKAROUND_5676(efx) ?
                           RESET_TYPE_RX_RECOVERY : RESET_TYPE_DISABLE);
@@ -873,9 +881,9 @@ efx_handle_generated_event(struct efx_channel *channel, efx_qword_t *event)
                 * queue. Refill it here */
                efx_fast_push_rx_descriptors(&efx->rx_queue[channel->channel]);
        else
-               EFX_LOG(efx, "channel %d received generated "
-                       "event "EFX_QWORD_FMT"\n", channel->channel,
-                       EFX_QWORD_VAL(*event));
+               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 */
@@ -901,8 +909,9 @@ efx_handle_global_event(struct efx_channel *channel, efx_qword_t *event)
        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)) {
-               EFX_ERR(efx, "channel %d seen global RX_RESET "
-                       "event. Resetting.\n", channel->channel);
+               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) ?
@@ -911,9 +920,10 @@ efx_handle_global_event(struct efx_channel *channel, efx_qword_t *event)
        }
 
        if (!handled)
-               EFX_ERR(efx, "channel %d unknown global event "
-                       EFX_QWORD_FMT "\n", channel->channel,
-                       EFX_QWORD_VAL(*event));
+               netif_err(efx, hw, efx->net_dev,
+                         "channel %d unknown global event "
+                         EFX_QWORD_FMT "\n", channel->channel,
+                         EFX_QWORD_VAL(*event));
 }
 
 static void
@@ -928,31 +938,35 @@ efx_handle_driver_event(struct efx_channel *channel, efx_qword_t *event)
 
        switch (ev_sub_code) {
        case FSE_AZ_TX_DESCQ_FLS_DONE_EV:
-               EFX_TRACE(efx, "channel %d TXQ %d flushed\n",
-                         channel->channel, ev_sub_data);
+               netif_vdbg(efx, hw, efx->net_dev, "channel %d TXQ %d flushed\n",
+                          channel->channel, ev_sub_data);
                break;
        case FSE_AZ_RX_DESCQ_FLS_DONE_EV:
-               EFX_TRACE(efx, "channel %d RXQ %d flushed\n",
-                         channel->channel, ev_sub_data);
+               netif_vdbg(efx, hw, efx->net_dev, "channel %d RXQ %d flushed\n",
+                          channel->channel, ev_sub_data);
                break;
        case FSE_AZ_EVQ_INIT_DONE_EV:
-               EFX_LOG(efx, "channel %d EVQ %d initialised\n",
-                       channel->channel, ev_sub_data);
+               netif_dbg(efx, hw, efx->net_dev,
+                         "channel %d EVQ %d initialised\n",
+                         channel->channel, ev_sub_data);
                break;
        case FSE_AZ_SRM_UPD_DONE_EV:
-               EFX_TRACE(efx, "channel %d SRAM update done\n",
-                         channel->channel);
+               netif_vdbg(efx, hw, efx->net_dev,
+                          "channel %d SRAM update done\n", channel->channel);
                break;
        case FSE_AZ_WAKE_UP_EV:
-               EFX_TRACE(efx, "channel %d RXQ %d wakeup event\n",
-                         channel->channel, ev_sub_data);
+               netif_vdbg(efx, hw, efx->net_dev,
+                          "channel %d RXQ %d wakeup event\n",
+                          channel->channel, ev_sub_data);
                break;
        case FSE_AZ_TIMER_EV:
-               EFX_TRACE(efx, "channel %d RX queue %d timer expired\n",
-                         channel->channel, ev_sub_data);
+               netif_vdbg(efx, hw, efx->net_dev,
+                          "channel %d RX queue %d timer expired\n",
+                          channel->channel, ev_sub_data);
                break;
        case FSE_AA_RX_RECOVER_EV:
-               EFX_ERR(efx, "channel %d seen DRIVER RX_RESET event. "
+               netif_err(efx, rx_err, efx->net_dev,
+                         "channel %d seen DRIVER RX_RESET event. "
                        "Resetting.\n", channel->channel);
                atomic_inc(&efx->rx_reset);
                efx_schedule_reset(efx,
@@ -961,19 +975,22 @@ efx_handle_driver_event(struct efx_channel *channel, efx_qword_t *event)
                                   RESET_TYPE_DISABLE);
                break;
        case FSE_BZ_RX_DSC_ERROR_EV:
-               EFX_ERR(efx, "RX DMA Q %d reports descriptor fetch error."
-                       " RX Q %d is disabled.\n", ev_sub_data, ev_sub_data);
+               netif_err(efx, rx_err, efx->net_dev,
+                         "RX DMA Q %d reports descriptor fetch error."
+                         " RX Q %d is disabled.\n", ev_sub_data, ev_sub_data);
                efx_schedule_reset(efx, RESET_TYPE_RX_DESC_FETCH);
                break;
        case FSE_BZ_TX_DSC_ERROR_EV:
-               EFX_ERR(efx, "TX DMA Q %d reports descriptor fetch error."
-                       " TX Q %d is disabled.\n", ev_sub_data, ev_sub_data);
+               netif_err(efx, tx_err, efx->net_dev,
+                         "TX DMA Q %d reports descriptor fetch error."
+                         " TX Q %d is disabled.\n", ev_sub_data, ev_sub_data);
                efx_schedule_reset(efx, RESET_TYPE_TX_DESC_FETCH);
                break;
        default:
-               EFX_TRACE(efx, "channel %d unknown driver event code %d "
-                         "data %04x\n", channel->channel, ev_sub_code,
-                         ev_sub_data);
+               netif_vdbg(efx, hw, efx->net_dev,
+                          "channel %d unknown driver event code %d "
+                          "data %04x\n", channel->channel, ev_sub_code,
+                          ev_sub_data);
                break;
        }
 }
@@ -996,8 +1013,9 @@ int efx_nic_process_eventq(struct efx_channel *channel, int budget)
                        /* End of events */
                        break;
 
-               EFX_TRACE(channel->efx, "channel %d event is "EFX_QWORD_FMT"\n",
-                         channel->channel, EFX_QWORD_VAL(event));
+               netif_vdbg(channel->efx, intr, channel->efx->net_dev,
+                          "channel %d event is "EFX_QWORD_FMT"\n",
+                          channel->channel, EFX_QWORD_VAL(event));
 
                /* Clear this event by marking it all ones */
                EFX_SET_QWORD(*p_event);
@@ -1033,9 +1051,10 @@ int efx_nic_process_eventq(struct efx_channel *channel, int budget)
                        efx_mcdi_process_event(channel, &event);
                        break;
                default:
-                       EFX_ERR(channel->efx, "channel %d unknown event type %d"
-                               " (data " EFX_QWORD_FMT ")\n", channel->channel,
-                               ev_code, EFX_QWORD_VAL(event));
+                       netif_err(channel->efx, hw, channel->efx->net_dev,
+                                 "channel %d unknown event type %d (data "
+                                 EFX_QWORD_FMT ")\n", channel->channel,
+                                 ev_code, EFX_QWORD_VAL(event));
                }
        }
 
@@ -1060,9 +1079,10 @@ void efx_nic_init_eventq(struct efx_channel *channel)
        efx_oword_t reg;
        struct efx_nic *efx = channel->efx;
 
-       EFX_LOG(efx, "channel %d event queue in special buffers %d-%d\n",
-               channel->channel, channel->eventq.index,
-               channel->eventq.index + channel->eventq.entries - 1);
+       netif_dbg(efx, hw, efx->net_dev,
+                 "channel %d event queue in special buffers %d-%d\n",
+                 channel->channel, channel->eventq.index,
+                 channel->eventq.index + channel->eventq.entries - 1);
 
        if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0) {
                EFX_POPULATE_OWORD_3(reg,
@@ -1240,14 +1260,16 @@ int efx_nic_flush_queues(struct efx_nic *efx)
         * leading to a reset, or fake up success anyway */
        efx_for_each_tx_queue(tx_queue, efx) {
                if (tx_queue->flushed != FLUSH_DONE)
-                       EFX_ERR(efx, "tx queue %d flush command timed out\n",
-                               tx_queue->queue);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "tx queue %d flush command timed out\n",
+                                 tx_queue->queue);
                tx_queue->flushed = FLUSH_DONE;
        }
        efx_for_each_rx_queue(rx_queue, efx) {
                if (rx_queue->flushed != FLUSH_DONE)
-                       EFX_ERR(efx, "rx queue %d flush command timed out\n",
-                               rx_queue->queue);
+                       netif_err(efx, hw, efx->net_dev,
+                                 "rx queue %d flush command timed out\n",
+                                 rx_queue->queue);
                rx_queue->flushed = FLUSH_DONE;
        }
 
@@ -1319,10 +1341,10 @@ irqreturn_t efx_nic_fatal_interrupt(struct efx_nic *efx)
        efx_reado(efx, &fatal_intr, FR_AZ_FATAL_INTR_KER);
        error = EFX_OWORD_FIELD(fatal_intr, FRF_AZ_FATAL_INTR);
 
-       EFX_ERR(efx, "SYSTEM ERROR " EFX_OWORD_FMT " status "
-               EFX_OWORD_FMT ": %s\n", EFX_OWORD_VAL(*int_ker),
-               EFX_OWORD_VAL(fatal_intr),
-               error ? "disabling bus mastering" : "no recognised error");
+       netif_err(efx, hw, efx->net_dev, "SYSTEM ERROR "EFX_OWORD_FMT" status "
+                 EFX_OWORD_FMT ": %s\n", EFX_OWORD_VAL(*int_ker),
+                 EFX_OWORD_VAL(fatal_intr),
+                 error ? "disabling bus mastering" : "no recognised error");
 
        /* If this is a memory parity error dump which blocks are offending */
        mem_perr = (EFX_OWORD_FIELD(fatal_intr, FRF_AZ_MEM_PERR_INT_KER) ||
@@ -1330,8 +1352,9 @@ irqreturn_t efx_nic_fatal_interrupt(struct efx_nic *efx)
        if (mem_perr) {
                efx_oword_t reg;
                efx_reado(efx, &reg, FR_AZ_MEM_STAT);
-               EFX_ERR(efx, "SYSTEM ERROR: memory parity error "
-                       EFX_OWORD_FMT "\n", EFX_OWORD_VAL(reg));
+               netif_err(efx, hw, efx->net_dev,
+                         "SYSTEM ERROR: memory parity error "EFX_OWORD_FMT"\n",
+                         EFX_OWORD_VAL(reg));
        }
 
        /* Disable both devices */
@@ -1348,11 +1371,13 @@ irqreturn_t efx_nic_fatal_interrupt(struct efx_nic *efx)
                        jiffies + EFX_INT_ERROR_EXPIRE * HZ;
        }
        if (++efx->int_error_count < EFX_MAX_INT_ERRORS) {
-               EFX_ERR(efx, "SYSTEM ERROR - reset scheduled\n");
+               netif_err(efx, hw, efx->net_dev,
+                         "SYSTEM ERROR - reset scheduled\n");
                efx_schedule_reset(efx, RESET_TYPE_INT_ERROR);
        } else {
-               EFX_ERR(efx, "SYSTEM ERROR - max number of errors seen."
-                       "NIC will be disabled\n");
+               netif_err(efx, hw, efx->net_dev,
+                         "SYSTEM ERROR - max number of errors seen."
+                         "NIC will be disabled\n");
                efx_schedule_reset(efx, RESET_TYPE_DISABLE);
        }
 
@@ -1415,8 +1440,9 @@ static irqreturn_t efx_legacy_interrupt(int irq, void *dev_id)
 
        if (result == IRQ_HANDLED) {
                efx->last_irq_cpu = raw_smp_processor_id();
-               EFX_TRACE(efx, "IRQ %d on CPU %d status " EFX_DWORD_FMT "\n",
-                         irq, raw_smp_processor_id(), EFX_DWORD_VAL(reg));
+               netif_vdbg(efx, intr, efx->net_dev,
+                          "IRQ %d on CPU %d status " EFX_DWORD_FMT "\n",
+                          irq, raw_smp_processor_id(), EFX_DWORD_VAL(reg));
        }
 
        return result;
@@ -1437,8 +1463,9 @@ static irqreturn_t efx_msi_interrupt(int irq, void *dev_id)
        int syserr;
 
        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));
 
        /* Check to see if we have a serious error condition */
        if (channel->channel == efx->fatal_irq_level) {
@@ -1494,8 +1521,9 @@ int efx_nic_init_interrupt(struct efx_nic *efx)
                rc = request_irq(efx->legacy_irq, handler, IRQF_SHARED,
                                 efx->name, efx);
                if (rc) {
-                       EFX_ERR(efx, "failed to hook legacy IRQ %d\n",
-                               efx->pci_dev->irq);
+                       netif_err(efx, drv, efx->net_dev,
+                                 "failed to hook legacy IRQ %d\n",
+                                 efx->pci_dev->irq);
                        goto fail1;
                }
                return 0;
@@ -1507,7 +1535,8 @@ int efx_nic_init_interrupt(struct efx_nic *efx)
                                 IRQF_PROBE_SHARED, /* Not shared */
                                 channel->name, channel);
                if (rc) {
-                       EFX_ERR(efx, "failed to hook IRQ %d\n", channel->irq);
+                       netif_err(efx, drv, efx->net_dev,
+                                 "failed to hook IRQ %d\n", channel->irq);
                        goto fail2;
                }
        }
index e077bef08a504258a4e37778c1778600cd640f92..68813d1d85f30eaac48648b7bb42b6e32ecaa34e 100644 (file)
@@ -91,9 +91,10 @@ static int qt2025c_wait_heartbeat(struct efx_nic *efx)
                if (time_after(jiffies, timeout)) {
                        /* Some cables have EEPROMs that conflict with the
                         * PHY's on-board EEPROM so it cannot load firmware */
-                       EFX_ERR(efx, "If an SFP+ direct attach cable is"
-                               " connected, please check that it complies"
-                               " with the SFP+ specification\n");
+                       netif_err(efx, hw, efx->net_dev,
+                                 "If an SFP+ direct attach cable is"
+                                 " connected, please check that it complies"
+                                 " with the SFP+ specification\n");
                        return -ETIMEDOUT;
                }
                msleep(QT2025C_HEARTB_WAIT);
@@ -145,7 +146,8 @@ static int qt2025c_wait_reset(struct efx_nic *efx)
                /* Bug 17689: occasionally heartbeat starts but firmware status
                 * code never progresses beyond 0x00.  Try again, once, after
                 * restarting execution of the firmware image. */
-               EFX_LOG(efx, "bashing QT2025C microcontroller\n");
+               netif_dbg(efx, hw, efx->net_dev,
+                         "bashing QT2025C microcontroller\n");
                qt2025c_restart_firmware(efx);
                rc = qt2025c_wait_heartbeat(efx);
                if (rc != 0)
@@ -165,11 +167,12 @@ static void qt2025c_firmware_id(struct efx_nic *efx)
        for (i = 0; i < sizeof(firmware_id); i++)
                firmware_id[i] = efx_mdio_read(efx, MDIO_MMD_PCS,
                                               PCS_FW_PRODUCT_CODE_1 + i);
-       EFX_INFO(efx, "QT2025C firmware %xr%d v%d.%d.%d.%d [20%02d-%02d-%02d]\n",
-                (firmware_id[0] << 8) | firmware_id[1], firmware_id[2],
-                firmware_id[3] >> 4, firmware_id[3] & 0xf,
-                firmware_id[4], firmware_id[5],
-                firmware_id[6], firmware_id[7], firmware_id[8]);
+       netif_info(efx, probe, efx->net_dev,
+                  "QT2025C firmware %xr%d v%d.%d.%d.%d [20%02d-%02d-%02d]\n",
+                  (firmware_id[0] << 8) | firmware_id[1], firmware_id[2],
+                  firmware_id[3] >> 4, firmware_id[3] & 0xf,
+                  firmware_id[4], firmware_id[5],
+                  firmware_id[6], firmware_id[7], firmware_id[8]);
        phy_data->firmware_ver = ((firmware_id[3] & 0xf0) << 20) |
                                 ((firmware_id[3] & 0x0f) << 16) |
                                 (firmware_id[4] << 8) | firmware_id[5];
@@ -198,7 +201,7 @@ static void qt2025c_bug17190_workaround(struct efx_nic *efx)
        }
 
        if (time_after_eq(jiffies, phy_data->bug17190_timer)) {
-               EFX_LOG(efx, "bashing QT2025C PMA/PMD\n");
+               netif_dbg(efx, hw, efx->net_dev, "bashing QT2025C PMA/PMD\n");
                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_CTRL1,
                                  MDIO_PMA_CTRL1_LOOPBACK, true);
                msleep(100);
@@ -231,7 +234,8 @@ static int qt2025c_select_phy_mode(struct efx_nic *efx)
        reg = efx_mdio_read(efx, 1, 0xc319);
        if ((reg & 0x0038) == phy_op_mode)
                return 0;
-       EFX_LOG(efx, "Switching PHY to mode 0x%04x\n", phy_op_mode);
+       netif_dbg(efx, hw, efx->net_dev, "Switching PHY to mode 0x%04x\n",
+                 phy_op_mode);
 
        /* This sequence replicates the register writes configured in the boot
         * EEPROM (including the differences between board revisions), except
@@ -287,8 +291,9 @@ static int qt2025c_select_phy_mode(struct efx_nic *efx)
        /* Wait for the microcontroller to be ready again */
        rc = qt2025c_wait_reset(efx);
        if (rc < 0) {
-               EFX_ERR(efx, "PHY microcontroller reset during mode switch "
-                               "timed out\n");
+               netif_err(efx, hw, efx->net_dev,
+                         "PHY microcontroller reset during mode switch "
+                         "timed out\n");
                return rc;
        }
 
@@ -324,7 +329,7 @@ static int qt202x_reset_phy(struct efx_nic *efx)
        return 0;
 
  fail:
-       EFX_ERR(efx, "PHY reset timed out\n");
+       netif_err(efx, hw, efx->net_dev, "PHY reset timed out\n");
        return rc;
 }
 
@@ -353,14 +358,15 @@ static int qt202x_phy_init(struct efx_nic *efx)
 
        rc = qt202x_reset_phy(efx);
        if (rc) {
-               EFX_ERR(efx, "PHY init failed\n");
+               netif_err(efx, probe, efx->net_dev, "PHY init failed\n");
                return rc;
        }
 
        devid = efx_mdio_read_id(efx, MDIO_MMD_PHYXS);
-       EFX_INFO(efx, "PHY ID reg %x (OUI %06x model %02x revision %x)\n",
-                devid, efx_mdio_id_oui(devid), efx_mdio_id_model(devid),
-                efx_mdio_id_rev(devid));
+       netif_info(efx, probe, efx->net_dev,
+                  "PHY ID reg %x (OUI %06x model %02x revision %x)\n",
+                  devid, efx_mdio_id_oui(devid), efx_mdio_id_model(devid),
+                  efx_mdio_id_rev(devid));
 
        if (efx->phy_type == PHY_TYPE_QT2025C)
                qt2025c_firmware_id(efx);
index 9fb698e3519db44e174d0af87b9f7729b3ae3dd6..d9ed20ee0dc544e305ae4161c87876fe3de6a41e 100644 (file)
@@ -348,10 +348,11 @@ void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
        if (space < EFX_RX_BATCH)
                goto out;
 
-       EFX_TRACE(rx_queue->efx, "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,
-                 channel->rx_alloc_push_pages ? "page" : "skb");
+       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,
+                  channel->rx_alloc_push_pages ? "page" : "skb");
 
        do {
                if (channel->rx_alloc_push_pages)
@@ -366,9 +367,10 @@ void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
                }
        } while ((space -= EFX_RX_BATCH) >= EFX_RX_BATCH);
 
-       EFX_TRACE(rx_queue->efx, "RX queue %d fast-filled descriptor ring "
-                 "to level %d\n", rx_queue->queue,
-                 rx_queue->added_count - rx_queue->removed_count);
+       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,
+                  rx_queue->added_count - rx_queue->removed_count);
 
  out:
        if (rx_queue->notified_count != rx_queue->added_count)
@@ -402,10 +404,12 @@ static void efx_rx_packet__check_len(struct efx_rx_queue *rx_queue,
        *discard = true;
 
        if ((len > rx_buf->len) && EFX_WORKAROUND_8071(efx)) {
-               EFX_ERR_RL(efx, " RX queue %d seriously overlength "
-                          "RX event (0x%x > 0x%x+0x%x). Leaking\n",
-                          rx_queue->queue, len, max_len,
-                          efx->type->rx_buffer_padding);
+               if (net_ratelimit())
+                       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->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.
@@ -413,8 +417,11 @@ static void efx_rx_packet__check_len(struct efx_rx_queue *rx_queue,
                *leak_packet = (rx_buf->skb != NULL);
                efx_schedule_reset(efx, RESET_TYPE_RX_RECOVERY);
        } else {
-               EFX_ERR_RL(efx, " RX queue %d overlength RX event "
-                          "(0x%x > 0x%x)\n", rx_queue->queue, len, max_len);
+               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);
        }
 
        rx_queue->channel->n_rx_overlength++;
@@ -502,11 +509,12 @@ void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
        efx_rx_packet__check_len(rx_queue, rx_buf, len,
                                 &discard, &leak_packet);
 
-       EFX_TRACE(efx, "RX queue %d received id %x at %llx+%x %s%s\n",
-                 rx_queue->queue, index,
-                 (unsigned long long)rx_buf->dma_addr, len,
-                 (checksummed ? " [SUMMED]" : ""),
-                 (discard ? " [DISCARD]" : ""));
+       netif_vdbg(efx, rx_status, efx->net_dev,
+                  "RX queue %d received id %x at %llx+%x %s%s\n",
+                  rx_queue->queue, index,
+                  (unsigned long long)rx_buf->dma_addr, len,
+                  (checksummed ? " [SUMMED]" : ""),
+                  (discard ? " [DISCARD]" : ""));
 
        /* Discard packet, if instructed to do so */
        if (unlikely(discard)) {
@@ -621,7 +629,8 @@ int efx_probe_rx_queue(struct efx_rx_queue *rx_queue)
        unsigned int rxq_size;
        int rc;
 
-       EFX_LOG(efx, "creating RX queue %d\n", rx_queue->queue);
+       netif_dbg(efx, probe, efx->net_dev,
+                 "creating RX queue %d\n", rx_queue->queue);
 
        /* Allocate RX buffers */
        rxq_size = EFX_RXQ_SIZE * sizeof(*rx_queue->buffer);
@@ -641,7 +650,8 @@ void efx_init_rx_queue(struct efx_rx_queue *rx_queue)
 {
        unsigned int max_fill, trigger, limit;
 
-       EFX_LOG(rx_queue->efx, "initialising RX queue %d\n", rx_queue->queue);
+       netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
+                 "initialising RX queue %d\n", rx_queue->queue);
 
        /* Initialise ptr fields */
        rx_queue->added_count = 0;
@@ -668,7 +678,8 @@ void efx_fini_rx_queue(struct efx_rx_queue *rx_queue)
        int i;
        struct efx_rx_buffer *rx_buf;
 
-       EFX_LOG(rx_queue->efx, "shutting down RX queue %d\n", rx_queue->queue);
+       netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
+                 "shutting down RX queue %d\n", rx_queue->queue);
 
        del_timer_sync(&rx_queue->slow_fill);
        efx_nic_fini_rx(rx_queue);
@@ -684,7 +695,8 @@ void efx_fini_rx_queue(struct efx_rx_queue *rx_queue)
 
 void efx_remove_rx_queue(struct efx_rx_queue *rx_queue)
 {
-       EFX_LOG(rx_queue->efx, "destroying RX queue %d\n", rx_queue->queue);
+       netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
+                 "destroying RX queue %d\n", rx_queue->queue);
 
        efx_nic_remove_rx(rx_queue);
 
index 1f83404af63be9e4dc21d6a57e88cc601b031cc7..85f015f005d5c12afecdf1a1db7fe91fbdd8c3f1 100644 (file)
@@ -123,7 +123,7 @@ static int efx_test_interrupts(struct efx_nic *efx,
 {
        struct efx_channel *channel;
 
-       EFX_LOG(efx, "testing interrupts\n");
+       netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n");
        tests->interrupt = -1;
 
        /* Reset interrupt flag */
@@ -142,16 +142,17 @@ static int efx_test_interrupts(struct efx_nic *efx,
        efx_nic_generate_interrupt(efx);
 
        /* Wait for arrival of test interrupt. */
-       EFX_LOG(efx, "waiting for test interrupt\n");
+       netif_dbg(efx, drv, efx->net_dev, "waiting for test interrupt\n");
        schedule_timeout_uninterruptible(HZ / 10);
        if (efx->last_irq_cpu >= 0)
                goto success;
 
-       EFX_ERR(efx, "timed out waiting for interrupt\n");
+       netif_err(efx, drv, efx->net_dev, "timed out waiting for interrupt\n");
        return -ETIMEDOUT;
 
  success:
-       EFX_LOG(efx, "%s test interrupt seen on CPU%d\n", INT_MODE(efx),
+       netif_dbg(efx, drv, efx->net_dev, "%s test interrupt seen on CPU%d\n",
+                 INT_MODE(efx),
                efx->last_irq_cpu);
        tests->interrupt = 1;
        return 0;
@@ -161,6 +162,7 @@ static int efx_test_interrupts(struct efx_nic *efx,
 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;
 
        tests->eventq_dma[channel->channel] = -1;
@@ -185,29 +187,32 @@ static int efx_test_eventq_irq(struct efx_channel *channel,
                        goto eventq_ok;
        } while (++count < 2);
 
-       EFX_ERR(channel->efx, "channel %d timed out waiting for event queue\n",
-               channel->channel);
+       netif_err(efx, drv, efx->net_dev,
+                 "channel %d timed out waiting for event queue\n",
+                 channel->channel);
 
        /* See if interrupt arrived */
        if (channel->efx->last_irq_cpu >= 0) {
-               EFX_ERR(channel->efx, "channel %d saw interrupt on CPU%d "
-                       "during event queue test\n", channel->channel,
-                       raw_smp_processor_id());
+               netif_err(efx, drv, efx->net_dev,
+                         "channel %d saw interrupt on CPU%d "
+                         "during event queue test\n", channel->channel,
+                         raw_smp_processor_id());
                tests->eventq_int[channel->channel] = 1;
        }
 
        /* Check to see if event was received even if interrupt wasn't */
        efx_process_channel_now(channel);
        if (channel->magic_count != magic_count) {
-               EFX_ERR(channel->efx, "channel %d event was generated, but "
-                       "failed to trigger an interrupt\n", channel->channel);
+               netif_err(efx, drv, efx->net_dev,
+                         "channel %d event was generated, but "
+                         "failed to trigger an interrupt\n", channel->channel);
                tests->eventq_dma[channel->channel] = 1;
        }
 
        return -ETIMEDOUT;
  eventq_ok:
-       EFX_LOG(channel->efx, "channel %d event queue passed\n",
-               channel->channel);
+       netif_dbg(efx, drv, efx->net_dev, "channel %d event queue passed\n",
+                 channel->channel);
        tests->eventq_dma[channel->channel] = 1;
        tests->eventq_int[channel->channel] = 1;
        tests->eventq_poll[channel->channel] = 1;
@@ -260,51 +265,57 @@ void efx_loopback_rx_packet(struct efx_nic *efx,
 
        /* Check that header exists */
        if (pkt_len < sizeof(received->header)) {
-               EFX_ERR(efx, "saw runt RX packet (length %d) in %s loopback "
-                       "test\n", pkt_len, LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw runt RX packet (length %d) in %s loopback "
+                         "test\n", pkt_len, LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Check that the ethernet header exists */
        if (memcmp(&received->header, &payload->header, ETH_HLEN) != 0) {
-               EFX_ERR(efx, "saw non-loopback RX packet in %s loopback test\n",
-                       LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw non-loopback RX packet in %s loopback test\n",
+                         LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Check packet length */
        if (pkt_len != sizeof(*payload)) {
-               EFX_ERR(efx, "saw incorrect RX packet length %d (wanted %d) in "
-                       "%s loopback test\n", pkt_len, (int)sizeof(*payload),
-                       LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw incorrect RX packet length %d (wanted %d) in "
+                         "%s loopback test\n", pkt_len, (int)sizeof(*payload),
+                         LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Check that IP header matches */
        if (memcmp(&received->ip, &payload->ip, sizeof(payload->ip)) != 0) {
-               EFX_ERR(efx, "saw corrupted IP header in %s loopback test\n",
-                       LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw corrupted IP header in %s loopback test\n",
+                         LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Check that msg and padding matches */
        if (memcmp(&received->msg, &payload->msg, sizeof(received->msg)) != 0) {
-               EFX_ERR(efx, "saw corrupted RX packet in %s loopback test\n",
-                       LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw corrupted RX packet in %s loopback test\n",
+                         LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Check that iteration matches */
        if (received->iteration != payload->iteration) {
-               EFX_ERR(efx, "saw RX packet from iteration %d (wanted %d) in "
-                       "%s loopback test\n", ntohs(received->iteration),
-                       ntohs(payload->iteration), LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "saw RX packet from iteration %d (wanted %d) in "
+                         "%s loopback test\n", ntohs(received->iteration),
+                         ntohs(payload->iteration), LOOPBACK_MODE(efx));
                goto err;
        }
 
        /* Increase correct RX count */
-       EFX_TRACE(efx, "got loopback RX in %s loopback test\n",
-                 LOOPBACK_MODE(efx));
+       netif_vdbg(efx, drv, efx->net_dev,
+                  "got loopback RX in %s loopback test\n", LOOPBACK_MODE(efx));
 
        atomic_inc(&state->rx_good);
        return;
@@ -312,10 +323,10 @@ void efx_loopback_rx_packet(struct efx_nic *efx,
  err:
 #ifdef EFX_ENABLE_DEBUG
        if (atomic_read(&state->rx_bad) == 0) {
-               EFX_ERR(efx, "received packet:\n");
+               netif_err(efx, drv, efx->net_dev, "received packet:\n");
                print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,
                               buf_ptr, pkt_len, 0);
-               EFX_ERR(efx, "expected packet:\n");
+               netif_err(efx, drv, efx->net_dev, "expected packet:\n");
                print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,
                               &state->payload, sizeof(state->payload), 0);
        }
@@ -396,9 +407,11 @@ static int efx_begin_loopback(struct efx_tx_queue *tx_queue)
                        netif_tx_unlock_bh(efx->net_dev);
 
                if (rc != NETDEV_TX_OK) {
-                       EFX_ERR(efx, "TX queue %d could not transmit packet %d "
-                               "of %d in %s loopback test\n", tx_queue->queue,
-                               i + 1, state->packet_count, LOOPBACK_MODE(efx));
+                       netif_err(efx, drv, efx->net_dev,
+                                 "TX queue %d could not transmit packet %d of "
+                                 "%d in %s loopback test\n", tx_queue->queue,
+                                 i + 1, state->packet_count,
+                                 LOOPBACK_MODE(efx));
 
                        /* Defer cleaning up the other skbs for the caller */
                        kfree_skb(skb);
@@ -454,20 +467,22 @@ static int efx_end_loopback(struct efx_tx_queue *tx_queue,
                /* Don't free the skbs; they will be picked up on TX
                 * overflow or channel teardown.
                 */
-               EFX_ERR(efx, "TX queue %d saw only %d out of an expected %d "
-                       "TX completion events in %s loopback test\n",
-                       tx_queue->queue, tx_done, state->packet_count,
-                       LOOPBACK_MODE(efx));
+               netif_err(efx, drv, efx->net_dev,
+                         "TX queue %d saw only %d out of an expected %d "
+                         "TX completion events in %s loopback test\n",
+                         tx_queue->queue, tx_done, state->packet_count,
+                         LOOPBACK_MODE(efx));
                rc = -ETIMEDOUT;
                /* Allow to fall through so we see the RX errors as well */
        }
 
        /* We may always be up to a flush away from our desired packet total */
        if (rx_good != state->packet_count) {
-               EFX_LOG(efx, "TX queue %d saw only %d out of an expected %d "
-                       "received packets in %s loopback test\n",
-                       tx_queue->queue, rx_good, state->packet_count,
-                       LOOPBACK_MODE(efx));
+               netif_dbg(efx, drv, efx->net_dev,
+                         "TX queue %d saw only %d out of an expected %d "
+                         "received packets in %s loopback test\n",
+                         tx_queue->queue, rx_good, state->packet_count,
+                         LOOPBACK_MODE(efx));
                rc = -ETIMEDOUT;
                /* Fall through */
        }
@@ -499,9 +514,10 @@ efx_test_loopback(struct efx_tx_queue *tx_queue,
                        return -ENOMEM;
                state->flush = false;
 
-               EFX_LOG(efx, "TX queue %d testing %s loopback with %d "
-                       "packets\n", tx_queue->queue, LOOPBACK_MODE(efx),
-                       state->packet_count);
+               netif_dbg(efx, drv, efx->net_dev,
+                         "TX queue %d testing %s loopback with %d packets\n",
+                         tx_queue->queue, LOOPBACK_MODE(efx),
+                         state->packet_count);
 
                efx_iterate_state(efx);
                begin_rc = efx_begin_loopback(tx_queue);
@@ -525,9 +541,10 @@ efx_test_loopback(struct efx_tx_queue *tx_queue,
                }
        }
 
-       EFX_LOG(efx, "TX queue %d passed %s loopback test with a burst length "
-               "of %d packets\n", tx_queue->queue, LOOPBACK_MODE(efx),
-               state->packet_count);
+       netif_dbg(efx, drv, efx->net_dev,
+                 "TX queue %d passed %s loopback test with a burst length "
+                 "of %d packets\n", tx_queue->queue, LOOPBACK_MODE(efx),
+                 state->packet_count);
 
        return 0;
 }
@@ -602,15 +619,17 @@ static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests,
                rc = __efx_reconfigure_port(efx);
                mutex_unlock(&efx->mac_lock);
                if (rc) {
-                       EFX_ERR(efx, "unable to move into %s loopback\n",
-                               LOOPBACK_MODE(efx));
+                       netif_err(efx, drv, efx->net_dev,
+                                 "unable to move into %s loopback\n",
+                                 LOOPBACK_MODE(efx));
                        goto out;
                }
 
                rc = efx_wait_for_link(efx);
                if (rc) {
-                       EFX_ERR(efx, "loopback %s never came up\n",
-                               LOOPBACK_MODE(efx));
+                       netif_err(efx, drv, efx->net_dev,
+                                 "loopback %s never came up\n",
+                                 LOOPBACK_MODE(efx));
                        goto out;
                }
 
@@ -718,7 +737,8 @@ int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests,
                rc_reset = rc;
 
        if (rc_reset) {
-               EFX_ERR(efx, "Unable to recover from chip test\n");
+               netif_err(efx, drv, efx->net_dev,
+                         "Unable to recover from chip test\n");
                efx_schedule_reset(efx, RESET_TYPE_DISABLE);
                return rc_reset;
        }
index f2b1e6180753536336921b90f53f62c8675fda72..59d1dc6db1c6ee5adbc9769f8f6c2b999dcbf240 100644 (file)
@@ -118,10 +118,11 @@ static int siena_probe_port(struct efx_nic *efx)
                                  MC_CMD_MAC_NSTATS * sizeof(u64));
        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));
 
        efx_mcdi_mac_stats(efx, efx->stats_buffer.dma_addr, 0, 0, 1);
 
@@ -216,7 +217,8 @@ static int siena_probe_nic(struct efx_nic *efx)
        efx->nic_data = nic_data;
 
        if (efx_nic_fpga_ver(efx) != 0) {
-               EFX_ERR(efx, "Siena FPGA not supported\n");
+               netif_err(efx, probe, efx->net_dev,
+                         "Siena FPGA not supported\n");
                rc = -ENODEV;
                goto fail1;
        }
@@ -233,8 +235,8 @@ static int siena_probe_nic(struct efx_nic *efx)
 
        rc = efx_mcdi_fwver(efx, &nic_data->fw_version, &nic_data->fw_build);
        if (rc) {
-               EFX_ERR(efx, "Failed to read MCPU firmware version - "
-                       "rc %d\n", rc);
+               netif_err(efx, probe, efx->net_dev,
+                         "Failed to read MCPU firmware version - rc %d\n", rc);
                goto fail1; /* MCPU absent? */
        }
 
@@ -242,17 +244,19 @@ static int siena_probe_nic(struct efx_nic *efx)
         * filter settings. We must do this before we reset the NIC */
        rc = efx_mcdi_drv_attach(efx, true, &already_attached);
        if (rc) {
-               EFX_ERR(efx, "Unable to register driver with MCPU\n");
+               netif_err(efx, probe, efx->net_dev,
+                         "Unable to register driver with MCPU\n");
                goto fail2;
        }
        if (already_attached)
                /* Not a fatal error */
-               EFX_ERR(efx, "Host already registered with MCPU\n");
+               netif_err(efx, probe, efx->net_dev,
+                         "Host already registered with MCPU\n");
 
        /* Now we can reset the NIC */
        rc = siena_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;
        }
 
@@ -264,15 +268,17 @@ static int siena_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",
-               (unsigned long long)efx->irq_status.dma_addr,
-               efx->irq_status.addr,
-               (unsigned long long)virt_to_phys(efx->irq_status.addr));
+       netif_dbg(efx, probe, efx->net_dev,
+                 "INT_KER at %llx (virt %p phys %llx)\n",
+                 (unsigned long long)efx->irq_status.dma_addr,
+                 efx->irq_status.addr,
+                 (unsigned long long)virt_to_phys(efx->irq_status.addr));
 
        /* Read in the non-volatile configuration */
        rc = siena_probe_nvconfig(efx);
        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;
        } else if (rc) {
@@ -344,7 +350,8 @@ static int siena_init_nic(struct efx_nic *efx)
 
        if (efx_nic_rx_xoff_thresh >= 0 || efx_nic_rx_xon_thresh >= 0)
                /* No MCDI operation has been defined to set thresholds */
-               EFX_ERR(efx, "ignoring RX flow control thresholds\n");
+               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);
@@ -565,7 +572,8 @@ static int siena_set_wol(struct efx_nic *efx, u32 type)
 
        return 0;
  fail:
-       EFX_ERR(efx, "%s failed: type=%d rc=%d\n", __func__, type, rc);
+       netif_err(efx, hw, efx->net_dev, "%s failed: type=%d rc=%d\n",
+                 __func__, type, rc);
        return rc;
 }
 
index f21efe7bd316e3618664cbcd0f1e94ef42a97ea9..6791be90c2fe095f213e8d94e3f5077f0e8053da 100644 (file)
@@ -228,7 +228,8 @@ int sft9001_wait_boot(struct efx_nic *efx)
                boot_stat = efx_mdio_read(efx, MDIO_MMD_PCS,
                                          PCS_BOOT_STATUS_REG);
                if (boot_stat >= 0) {
-                       EFX_LOG(efx, "PHY boot status = %#x\n", boot_stat);
+                       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) |
@@ -463,10 +464,11 @@ static void sfx7101_check_bad_lp(struct efx_nic *efx, bool link_ok)
                        reg |= PMA_PMD_LED_OFF << PMA_PMD_LED_RX_LBN;
                } else {
                        reg |= PMA_PMD_LED_FLASH << PMA_PMD_LED_RX_LBN;
-                       EFX_ERR(efx, "appears to be plugged into a port"
-                               " that is not 10GBASE-T capable. The PHY"
-                               " supports 10GBASE-T ONLY, so no link can"
-                               " be established\n");
+                       netif_err(efx, link, efx->net_dev,
+                                 "appears to be plugged into a port"
+                                 " that is not 10GBASE-T capable. The PHY"
+                                 " supports 10GBASE-T ONLY, so no link can"
+                                 " be established\n");
                }
                efx_mdio_write(efx, MDIO_MMD_PMAPMD,
                               PMA_PMD_LED_OVERR_REG, reg);
index 6bb12a87ef2d5f4292f4343f41e6ed010fd5f14f..c6942da2c99af75b6749c7b94edf7b8204cdc676 100644 (file)
@@ -42,7 +42,7 @@ void efx_stop_queue(struct efx_channel *channel)
                return;
 
        spin_lock_bh(&channel->tx_stop_lock);
-       EFX_TRACE(efx, "stop TX queue\n");
+       netif_vdbg(efx, tx_queued, efx->net_dev, "stop TX queue\n");
 
        atomic_inc(&channel->tx_stop_count);
        netif_tx_stop_queue(
@@ -64,7 +64,7 @@ void efx_wake_queue(struct efx_channel *channel)
        local_bh_disable();
        if (atomic_dec_and_lock(&channel->tx_stop_count,
                                &channel->tx_stop_lock)) {
-               EFX_TRACE(efx, "waking TX queue\n");
+               netif_vdbg(efx, tx_queued, efx->net_dev, "waking TX queue\n");
                netif_tx_wake_queue(
                        netdev_get_tx_queue(
                                efx->net_dev,
@@ -94,8 +94,9 @@ static void efx_dequeue_buffer(struct efx_tx_queue *tx_queue,
        if (buffer->skb) {
                dev_kfree_skb_any((struct sk_buff *) buffer->skb);
                buffer->skb = NULL;
-               EFX_TRACE(tx_queue->efx, "TX queue %d transmission id %x "
-                         "complete\n", tx_queue->queue, read_ptr);
+               netif_vdbg(tx_queue->efx, tx_done, tx_queue->efx->net_dev,
+                          "TX queue %d transmission id %x complete\n",
+                          tx_queue->queue, tx_queue->read_count);
        }
 }
 
@@ -300,9 +301,10 @@ netdev_tx_t efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb)
        return NETDEV_TX_OK;
 
  pci_err:
-       EFX_ERR_RL(efx, " TX queue %d could not map skb with %d bytes %d "
-                  "fragments for DMA\n", tx_queue->queue, skb->len,
-                  skb_shinfo(skb)->nr_frags + 1);
+       netif_err(efx, tx_err, efx->net_dev,
+                 " TX queue %d could not map skb with %d bytes %d "
+                 "fragments for DMA\n", tx_queue->queue, skb->len,
+                 skb_shinfo(skb)->nr_frags + 1);
 
        /* Mark the packet as transmitted, and free the SKB ourselves */
        dev_kfree_skb_any(skb);
@@ -354,9 +356,9 @@ static void efx_dequeue_buffers(struct efx_tx_queue *tx_queue,
        while (read_ptr != stop_index) {
                struct efx_tx_buffer *buffer = &tx_queue->buffer[read_ptr];
                if (unlikely(buffer->len == 0)) {
-                       EFX_ERR(tx_queue->efx, "TX queue %d spurious TX "
-                               "completion id %x\n", tx_queue->queue,
-                               read_ptr);
+                       netif_err(efx, tx_err, efx->net_dev,
+                                 "TX queue %d spurious TX completion id %x\n",
+                                 tx_queue->queue, read_ptr);
                        efx_schedule_reset(efx, RESET_TYPE_TX_SKIP);
                        return;
                }
@@ -431,7 +433,8 @@ int efx_probe_tx_queue(struct efx_tx_queue *tx_queue)
        unsigned int txq_size;
        int i, rc;
 
-       EFX_LOG(efx, "creating TX queue %d\n", tx_queue->queue);
+       netif_dbg(efx, probe, efx->net_dev, "creating TX queue %d\n",
+                 tx_queue->queue);
 
        /* Allocate software ring */
        txq_size = EFX_TXQ_SIZE * sizeof(*tx_queue->buffer);
@@ -456,7 +459,8 @@ int efx_probe_tx_queue(struct efx_tx_queue *tx_queue)
 
 void efx_init_tx_queue(struct efx_tx_queue *tx_queue)
 {
-       EFX_LOG(tx_queue->efx, "initialising TX queue %d\n", tx_queue->queue);
+       netif_dbg(tx_queue->efx, drv, tx_queue->efx->net_dev,
+                 "initialising TX queue %d\n", tx_queue->queue);
 
        tx_queue->insert_count = 0;
        tx_queue->write_count = 0;
@@ -488,7 +492,8 @@ void efx_release_tx_buffers(struct efx_tx_queue *tx_queue)
 
 void efx_fini_tx_queue(struct efx_tx_queue *tx_queue)
 {
-       EFX_LOG(tx_queue->efx, "shutting down TX queue %d\n", tx_queue->queue);
+       netif_dbg(tx_queue->efx, drv, tx_queue->efx->net_dev,
+                 "shutting down TX queue %d\n", tx_queue->queue);
 
        /* Flush TX queue, remove descriptor ring */
        efx_nic_fini_tx(tx_queue);
@@ -507,7 +512,8 @@ void efx_fini_tx_queue(struct efx_tx_queue *tx_queue)
 
 void efx_remove_tx_queue(struct efx_tx_queue *tx_queue)
 {
-       EFX_LOG(tx_queue->efx, "destroying TX queue %d\n", tx_queue->queue);
+       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);
 
        kfree(tx_queue->buffer);
@@ -639,8 +645,8 @@ static int efx_tsoh_block_alloc(struct efx_tx_queue *tx_queue)
 
        base_kva = pci_alloc_consistent(pci_dev, PAGE_SIZE, &dma_addr);
        if (base_kva == NULL) {
-               EFX_ERR(tx_queue->efx, "Unable to allocate page for TSO"
-                       " headers\n");
+               netif_err(tx_queue->efx, tx_err, tx_queue->efx->net_dev,
+                         "Unable to allocate page for TSO headers\n");
                return -ENOMEM;
        }
 
@@ -1124,7 +1130,8 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue,
        return NETDEV_TX_OK;
 
  mem_err:
-       EFX_ERR(efx, "Out of memory for TSO headers, or PCI mapping error\n");
+       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;