sfc: Implement message level control

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

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

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

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

1 files changed, 73 insertions, 53 deletions

diff --git a/drivers/net/sfc/selftest.c b/drivers/net/sfc/selftest.c
index 1f83404af63b..85f015f005d5 100644
--- a/drivers/net/sfc/selftest.c
+++ b/drivers/net/sfc/selftest.c
@@ -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;
         }