drivers/net/ethernet/sfc/falcon/selftest.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /****************************************************************************
   3  * Driver for Solarflare network controllers and boards
   4  * Copyright 2005-2006 Fen Systems Ltd.
   5  * Copyright 2006-2012 Solarflare Communications Inc.
   6  */
   7
   8 #include <linux/netdevice.h>
   9 #include <linux/module.h>
  10 #include <linux/delay.h>
  11 #include <linux/kernel_stat.h>
  12 #include <linux/pci.h>
  13 #include <linux/ethtool.h>
  14 #include <linux/ip.h>
  15 #include <linux/in.h>
  16 #include <linux/udp.h>
  17 #include <linux/rtnetlink.h>
  18 #include <linux/slab.h>
  19 #include "net_driver.h"
  20 #include "efx.h"
  21 #include "nic.h"
  22 #include "selftest.h"
  23 #include "workarounds.h"
  24
  25 /* IRQ latency can be enormous because:
  26  * - All IRQs may be disabled on a CPU for a *long* time by e.g. a
  27  *   slow serial console or an old IDE driver doing error recovery
  28  * - The PREEMPT_RT patches mostly deal with this, but also allow a
  29  *   tasklet or normal task to be given higher priority than our IRQ
  30  *   threads
  31  * Try to avoid blaming the hardware for this.
  32  */
  33 #define IRQ_TIMEOUT HZ
  34
  35 /*
  36  * Loopback test packet structure
  37  *
  38  * The self-test should stress every RSS vector, and unfortunately
  39  * Falcon only performs RSS on TCP/UDP packets.
  40  */
  41 struct ef4_loopback_payload {
  42         char pad[2]; /* Ensures ip is 4-byte aligned */
  43         struct ethhdr header;
  44         struct iphdr ip;
  45         struct udphdr udp;
  46         __be16 iteration;
  47         char msg[64];
  48 } __packed __aligned(4);
  49 #define EF4_LOOPBACK_PAYLOAD_LEN        (sizeof(struct ef4_loopback_payload) - \
  50                                          offsetof(struct ef4_loopback_payload, \
  51                                                   header))
  52
  53 /* Loopback test source MAC address */
  54 static const u8 payload_source[ETH_ALEN] __aligned(2) = {
  55         0x00, 0x0f, 0x53, 0x1b, 0x1b, 0x1b,
  56 };
  57
  58 static const char payload_msg[] =
  59         "Hello world! This is an Efx loopback test in progress!";
  60
  61 /* Interrupt mode names */
  62 static const unsigned int ef4_interrupt_mode_max = EF4_INT_MODE_MAX;
  63 static const char *const ef4_interrupt_mode_names[] = {
  64         [EF4_INT_MODE_MSIX]   = "MSI-X",
  65         [EF4_INT_MODE_MSI]    = "MSI",
  66         [EF4_INT_MODE_LEGACY] = "legacy",
  67 };
  68 #define INT_MODE(efx) \
  69         STRING_TABLE_LOOKUP(efx->interrupt_mode, ef4_interrupt_mode)
  70
  71 /**
  72  * struct ef4_loopback_state - persistent state during a loopback selftest
  73  * @flush:              Drop all packets in ef4_loopback_rx_packet
  74  * @packet_count:       Number of packets being used in this test
  75  * @skbs:               An array of skbs transmitted
  76  * @offload_csum:       Checksums are being offloaded
  77  * @rx_good:            RX good packet count
  78  * @rx_bad:             RX bad packet count
  79  * @payload:            Payload used in tests
  80  */
  81 struct ef4_loopback_state {
  82         bool flush;
  83         int packet_count;
  84         struct sk_buff **skbs;
  85         bool offload_csum;
  86         atomic_t rx_good;
  87         atomic_t rx_bad;
  88         struct ef4_loopback_payload payload;
  89 };
  90
  91 /* How long to wait for all the packets to arrive (in ms) */
  92 #define LOOPBACK_TIMEOUT_MS 1000
  93
  94 /**************************************************************************
  95  *
  96  * MII, NVRAM and register tests
  97  *
  98  **************************************************************************/
  99
 100 static int ef4_test_phy_alive(struct ef4_nic *efx, struct ef4_self_tests *tests)
 101 {
 102         int rc = 0;
 103
 104         if (efx->phy_op->test_alive) {
 105                 rc = efx->phy_op->test_alive(efx);
 106                 tests->phy_alive = rc ? -1 : 1;
 107         }
 108
 109         return rc;
 110 }
 111
 112 static int ef4_test_nvram(struct ef4_nic *efx, struct ef4_self_tests *tests)
 113 {
 114         int rc = 0;
 115
 116         if (efx->type->test_nvram) {
 117                 rc = efx->type->test_nvram(efx);
 118                 if (rc == -EPERM)
 119                         rc = 0;
 120                 else
 121                         tests->nvram = rc ? -1 : 1;
 122         }
 123
 124         return rc;
 125 }
 126
 127 /**************************************************************************
 128  *
 129  * Interrupt and event queue testing
 130  *
 131  **************************************************************************/
 132
 133 /* Test generation and receipt of interrupts */
 134 static int ef4_test_interrupts(struct ef4_nic *efx,
 135                                struct ef4_self_tests *tests)
 136 {
 137         unsigned long timeout, wait;
 138         int cpu;
 139         int rc;
 140
 141         netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n");
 142         tests->interrupt = -1;
 143
 144         rc = ef4_nic_irq_test_start(efx);
 145         if (rc == -ENOTSUPP) {
 146                 netif_dbg(efx, drv, efx->net_dev,
 147                           "direct interrupt testing not supported\n");
 148                 tests->interrupt = 0;
 149                 return 0;
 150         }
 151
 152         timeout = jiffies + IRQ_TIMEOUT;
 153         wait = 1;
 154
 155         /* Wait for arrival of test interrupt. */
 156         netif_dbg(efx, drv, efx->net_dev, "waiting for test interrupt\n");
 157         do {
 158                 schedule_timeout_uninterruptible(wait);
 159                 cpu = ef4_nic_irq_test_irq_cpu(efx);
 160                 if (cpu >= 0)
 161                         goto success;
 162                 wait *= 2;
 163         } while (time_before(jiffies, timeout));
 164
 165         netif_err(efx, drv, efx->net_dev, "timed out waiting for interrupt\n");
 166         return -ETIMEDOUT;
 167
 168  success:
 169         netif_dbg(efx, drv, efx->net_dev, "%s test interrupt seen on CPU%d\n",
 170                   INT_MODE(efx), cpu);
 171         tests->interrupt = 1;
 172         return 0;
 173 }
 174
 175 /* Test generation and receipt of interrupting events */
 176 static int ef4_test_eventq_irq(struct ef4_nic *efx,
 177                                struct ef4_self_tests *tests)
 178 {
 179         struct ef4_channel *channel;
 180         unsigned int read_ptr[EF4_MAX_CHANNELS];
 181         unsigned long napi_ran = 0, dma_pend = 0, int_pend = 0;
 182         unsigned long timeout, wait;
 183
 184         BUILD_BUG_ON(EF4_MAX_CHANNELS > BITS_PER_LONG);
 185
 186         ef4_for_each_channel(channel, efx) {
 187                 read_ptr[channel->channel] = channel->eventq_read_ptr;
 188                 set_bit(channel->channel, &dma_pend);
 189                 set_bit(channel->channel, &int_pend);
 190                 ef4_nic_event_test_start(channel);
 191         }
 192
 193         timeout = jiffies + IRQ_TIMEOUT;
 194         wait = 1;
 195
 196         /* Wait for arrival of interrupts.  NAPI processing may or may
 197          * not complete in time, but we can cope in any case.
 198          */
 199         do {
 200                 schedule_timeout_uninterruptible(wait);
 201
 202                 ef4_for_each_channel(channel, efx) {
 203                         ef4_stop_eventq(channel);
 204                         if (channel->eventq_read_ptr !=
 205                             read_ptr[channel->channel]) {
 206                                 set_bit(channel->channel, &napi_ran);
 207                                 clear_bit(channel->channel, &dma_pend);
 208                                 clear_bit(channel->channel, &int_pend);
 209                         } else {
 210                                 if (ef4_nic_event_present(channel))
 211                                         clear_bit(channel->channel, &dma_pend);
 212                                 if (ef4_nic_event_test_irq_cpu(channel) >= 0)
 213                                         clear_bit(channel->channel, &int_pend);
 214                         }
 215                         ef4_start_eventq(channel);
 216                 }
 217
 218                 wait *= 2;
 219         } while ((dma_pend || int_pend) && time_before(jiffies, timeout));
 220
 221         ef4_for_each_channel(channel, efx) {
 222                 bool dma_seen = !test_bit(channel->channel, &dma_pend);
 223                 bool int_seen = !test_bit(channel->channel, &int_pend);
 224
 225                 tests->eventq_dma[channel->channel] = dma_seen ? 1 : -1;
 226                 tests->eventq_int[channel->channel] = int_seen ? 1 : -1;
 227
 228                 if (dma_seen && int_seen) {
 229                         netif_dbg(efx, drv, efx->net_dev,
 230                                   "channel %d event queue passed (with%s NAPI)\n",
 231                                   channel->channel,
 232                                   test_bit(channel->channel, &napi_ran) ?
 233                                   "" : "out");
 234                 } else {
 235                         /* Report failure and whether either interrupt or DMA
 236                          * worked
 237                          */
 238                         netif_err(efx, drv, efx->net_dev,
 239                                   "channel %d timed out waiting for event queue\n",
 240                                   channel->channel);
 241                         if (int_seen)
 242                                 netif_err(efx, drv, efx->net_dev,
 243                                           "channel %d saw interrupt "
 244                                           "during event queue test\n",
 245                                           channel->channel);
 246                         if (dma_seen)
 247                                 netif_err(efx, drv, efx->net_dev,
 248                                           "channel %d event was generated, but "
 249                                           "failed to trigger an interrupt\n",
 250                                           channel->channel);
 251                 }
 252         }
 253
 254         return (dma_pend || int_pend) ? -ETIMEDOUT : 0;
 255 }
 256
 257 static int ef4_test_phy(struct ef4_nic *efx, struct ef4_self_tests *tests,
 258                         unsigned flags)
 259 {
 260         int rc;
 261
 262         if (!efx->phy_op->run_tests)
 263                 return 0;
 264
 265         mutex_lock(&efx->mac_lock);
 266         rc = efx->phy_op->run_tests(efx, tests->phy_ext, flags);
 267         mutex_unlock(&efx->mac_lock);
 268         if (rc == -EPERM)
 269                 rc = 0;
 270         else
 271                 netif_info(efx, drv, efx->net_dev,
 272                            "%s phy selftest\n", rc ? "Failed" : "Passed");
 273
 274         return rc;
 275 }
 276
 277 /**************************************************************************
 278  *
 279  * Loopback testing
 280  * NB Only one loopback test can be executing concurrently.
 281  *
 282  **************************************************************************/
 283
 284 /* Loopback test RX callback
 285  * This is called for each received packet during loopback testing.
 286  */
 287 void ef4_loopback_rx_packet(struct ef4_nic *efx,
 288                             const char *buf_ptr, int pkt_len)
 289 {
 290         struct ef4_loopback_state *state = efx->loopback_selftest;
 291         struct ef4_loopback_payload received;
 292         struct ef4_loopback_payload *payload;
 293
 294         BUG_ON(!buf_ptr);
 295
 296         /* If we are just flushing, then drop the packet */
 297         if ((state == NULL) || state->flush)
 298                 return;
 299
 300         payload = &state->payload;
 301
 302         memcpy(&received.header, buf_ptr,
 303                min_t(int, pkt_len, EF4_LOOPBACK_PAYLOAD_LEN));
 304         received.ip.saddr = payload->ip.saddr;
 305         if (state->offload_csum)
 306                 received.ip.check = payload->ip.check;
 307
 308         /* Check that header exists */
 309         if (pkt_len < sizeof(received.header)) {
 310                 netif_err(efx, drv, efx->net_dev,
 311                           "saw runt RX packet (length %d) in %s loopback "
 312                           "test\n", pkt_len, LOOPBACK_MODE(efx));
 313                 goto err;
 314         }
 315
 316         /* Check that the ethernet header exists */
 317         if (memcmp(&received.header, &payload->header, ETH_HLEN) != 0) {
 318                 netif_err(efx, drv, efx->net_dev,
 319                           "saw non-loopback RX packet in %s loopback test\n",
 320                           LOOPBACK_MODE(efx));
 321                 goto err;
 322         }
 323
 324         /* Check packet length */
 325         if (pkt_len != EF4_LOOPBACK_PAYLOAD_LEN) {
 326                 netif_err(efx, drv, efx->net_dev,
 327                           "saw incorrect RX packet length %d (wanted %d) in "
 328                           "%s loopback test\n", pkt_len,
 329                           (int)EF4_LOOPBACK_PAYLOAD_LEN, LOOPBACK_MODE(efx));
 330                 goto err;
 331         }
 332
 333         /* Check that IP header matches */
 334         if (memcmp(&received.ip, &payload->ip, sizeof(payload->ip)) != 0) {
 335                 netif_err(efx, drv, efx->net_dev,
 336                           "saw corrupted IP header in %s loopback test\n",
 337                           LOOPBACK_MODE(efx));
 338                 goto err;
 339         }
 340
 341         /* Check that msg and padding matches */
 342         if (memcmp(&received.msg, &payload->msg, sizeof(received.msg)) != 0) {
 343                 netif_err(efx, drv, efx->net_dev,
 344                           "saw corrupted RX packet in %s loopback test\n",
 345                           LOOPBACK_MODE(efx));
 346                 goto err;
 347         }
 348
 349         /* Check that iteration matches */
 350         if (received.iteration != payload->iteration) {
 351                 netif_err(efx, drv, efx->net_dev,
 352                           "saw RX packet from iteration %d (wanted %d) in "
 353                           "%s loopback test\n", ntohs(received.iteration),
 354                           ntohs(payload->iteration), LOOPBACK_MODE(efx));
 355                 goto err;
 356         }
 357
 358         /* Increase correct RX count */
 359         netif_vdbg(efx, drv, efx->net_dev,
 360                    "got loopback RX in %s loopback test\n", LOOPBACK_MODE(efx));
 361
 362         atomic_inc(&state->rx_good);
 363         return;
 364
 365  err:
 366 #ifdef DEBUG
 367         if (atomic_read(&state->rx_bad) == 0) {
 368                 netif_err(efx, drv, efx->net_dev, "received packet:\n");
 369                 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,
 370                                buf_ptr, pkt_len, 0);
 371                 netif_err(efx, drv, efx->net_dev, "expected packet:\n");
 372                 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,
 373                                &state->payload.header, EF4_LOOPBACK_PAYLOAD_LEN,
 374                                0);
 375         }
 376 #endif
 377         atomic_inc(&state->rx_bad);
 378 }
 379
 380 /* Initialise an ef4_selftest_state for a new iteration */
 381 static void ef4_iterate_state(struct ef4_nic *efx)
 382 {
 383         struct ef4_loopback_state *state = efx->loopback_selftest;
 384         struct net_device *net_dev = efx->net_dev;
 385         struct ef4_loopback_payload *payload = &state->payload;
 386
 387         /* Initialise the layerII header */
 388         ether_addr_copy((u8 *)&payload->header.h_dest, net_dev->dev_addr);
 389         ether_addr_copy((u8 *)&payload->header.h_source, payload_source);
 390         payload->header.h_proto = htons(ETH_P_IP);
 391
 392         /* saddr set later and used as incrementing count */
 393         payload->ip.daddr = htonl(INADDR_LOOPBACK);
 394         payload->ip.ihl = 5;
 395         payload->ip.check = (__force __sum16) htons(0xdead);
 396         payload->ip.tot_len = htons(sizeof(*payload) -
 397                                     offsetof(struct ef4_loopback_payload, ip));
 398         payload->ip.version = IPVERSION;
 399         payload->ip.protocol = IPPROTO_UDP;
 400
 401         /* Initialise udp header */
 402         payload->udp.source = 0;
 403         payload->udp.len = htons(sizeof(*payload) -
 404                                  offsetof(struct ef4_loopback_payload, udp));
 405         payload->udp.check = 0; /* checksum ignored */
 406
 407         /* Fill out payload */
 408         payload->iteration = htons(ntohs(payload->iteration) + 1);
 409         memcpy(&payload->msg, payload_msg, sizeof(payload_msg));
 410
 411         /* Fill out remaining state members */
 412         atomic_set(&state->rx_good, 0);
 413         atomic_set(&state->rx_bad, 0);
 414         smp_wmb();
 415 }
 416
 417 static int ef4_begin_loopback(struct ef4_tx_queue *tx_queue)
 418 {
 419         struct ef4_nic *efx = tx_queue->efx;
 420         struct ef4_loopback_state *state = efx->loopback_selftest;
 421         struct ef4_loopback_payload *payload;
 422         struct sk_buff *skb;
 423         int i;
 424         netdev_tx_t rc;
 425
 426         /* Transmit N copies of buffer */
 427         for (i = 0; i < state->packet_count; i++) {
 428                 /* Allocate an skb, holding an extra reference for
 429                  * transmit completion counting */
 430                 skb = alloc_skb(EF4_LOOPBACK_PAYLOAD_LEN, GFP_KERNEL);
 431                 if (!skb)
 432                         return -ENOMEM;
 433                 state->skbs[i] = skb;
 434                 skb_get(skb);
 435
 436                 /* Copy the payload in, incrementing the source address to
 437                  * exercise the rss vectors */
 438                 payload = skb_put(skb, sizeof(state->payload));
 439                 memcpy(payload, &state->payload, sizeof(state->payload));
 440                 payload->ip.saddr = htonl(INADDR_LOOPBACK | (i << 2));
 441                 /* Strip off the leading padding */
 442                 skb_pull(skb, offsetof(struct ef4_loopback_payload, header));
 443
 444                 /* Ensure everything we've written is visible to the
 445                  * interrupt handler. */
 446                 smp_wmb();
 447
 448                 netif_tx_lock_bh(efx->net_dev);
 449                 rc = ef4_enqueue_skb(tx_queue, skb);
 450                 netif_tx_unlock_bh(efx->net_dev);
 451
 452                 if (rc != NETDEV_TX_OK) {
 453                         netif_err(efx, drv, efx->net_dev,
 454                                   "TX queue %d could not transmit packet %d of "
 455                                   "%d in %s loopback test\n", tx_queue->queue,
 456                                   i + 1, state->packet_count,
 457                                   LOOPBACK_MODE(efx));
 458
 459                         /* Defer cleaning up the other skbs for the caller */
 460                         kfree_skb(skb);
 461                         return -EPIPE;
 462                 }
 463         }
 464
 465         return 0;
 466 }
 467
 468 static int ef4_poll_loopback(struct ef4_nic *efx)
 469 {
 470         struct ef4_loopback_state *state = efx->loopback_selftest;
 471
 472         return atomic_read(&state->rx_good) == state->packet_count;
 473 }
 474
 475 static int ef4_end_loopback(struct ef4_tx_queue *tx_queue,
 476                             struct ef4_loopback_self_tests *lb_tests)
 477 {
 478         struct ef4_nic *efx = tx_queue->efx;
 479         struct ef4_loopback_state *state = efx->loopback_selftest;
 480         struct sk_buff *skb;
 481         int tx_done = 0, rx_good, rx_bad;
 482         int i, rc = 0;
 483
 484         netif_tx_lock_bh(efx->net_dev);
 485
 486         /* Count the number of tx completions, and decrement the refcnt. Any
 487          * skbs not already completed will be free'd when the queue is flushed */
 488         for (i = 0; i < state->packet_count; i++) {
 489                 skb = state->skbs[i];
 490                 if (skb && !skb_shared(skb))
 491                         ++tx_done;
 492                 dev_kfree_skb(skb);
 493         }
 494
 495         netif_tx_unlock_bh(efx->net_dev);
 496
 497         /* Check TX completion and received packet counts */
 498         rx_good = atomic_read(&state->rx_good);
 499         rx_bad = atomic_read(&state->rx_bad);
 500         if (tx_done != state->packet_count) {
 501                 /* Don't free the skbs; they will be picked up on TX
 502                  * overflow or channel teardown.
 503                  */
 504                 netif_err(efx, drv, efx->net_dev,
 505                           "TX queue %d saw only %d out of an expected %d "
 506                           "TX completion events in %s loopback test\n",
 507                           tx_queue->queue, tx_done, state->packet_count,
 508                           LOOPBACK_MODE(efx));
 509                 rc = -ETIMEDOUT;
 510                 /* Allow to fall through so we see the RX errors as well */
 511         }
 512
 513         /* We may always be up to a flush away from our desired packet total */
 514         if (rx_good != state->packet_count) {
 515                 netif_dbg(efx, drv, efx->net_dev,
 516                           "TX queue %d saw only %d out of an expected %d "
 517                           "received packets in %s loopback test\n",
 518                           tx_queue->queue, rx_good, state->packet_count,
 519                           LOOPBACK_MODE(efx));
 520                 rc = -ETIMEDOUT;
 521                 /* Fall through */
 522         }
 523
 524         /* Update loopback test structure */
 525         lb_tests->tx_sent[tx_queue->queue] += state->packet_count;
 526         lb_tests->tx_done[tx_queue->queue] += tx_done;
 527         lb_tests->rx_good += rx_good;
 528         lb_tests->rx_bad += rx_bad;
 529
 530         return rc;
 531 }
 532
 533 static int
 534 ef4_test_loopback(struct ef4_tx_queue *tx_queue,
 535                   struct ef4_loopback_self_tests *lb_tests)
 536 {
 537         struct ef4_nic *efx = tx_queue->efx;
 538         struct ef4_loopback_state *state = efx->loopback_selftest;
 539         int i, begin_rc, end_rc;
 540
 541         for (i = 0; i < 3; i++) {
 542                 /* Determine how many packets to send */
 543                 state->packet_count = efx->txq_entries / 3;
 544                 state->packet_count = min(1 << (i << 2), state->packet_count);
 545                 state->skbs = kcalloc(state->packet_count,
 546                                       sizeof(state->skbs[0]), GFP_KERNEL);
 547                 if (!state->skbs)
 548                         return -ENOMEM;
 549                 state->flush = false;
 550
 551                 netif_dbg(efx, drv, efx->net_dev,
 552                           "TX queue %d testing %s loopback with %d packets\n",
 553                           tx_queue->queue, LOOPBACK_MODE(efx),
 554                           state->packet_count);
 555
 556                 ef4_iterate_state(efx);
 557                 begin_rc = ef4_begin_loopback(tx_queue);
 558
 559                 /* This will normally complete very quickly, but be
 560                  * prepared to wait much longer. */
 561                 msleep(1);
 562                 if (!ef4_poll_loopback(efx)) {
 563                         msleep(LOOPBACK_TIMEOUT_MS);
 564                         ef4_poll_loopback(efx);
 565                 }
 566
 567                 end_rc = ef4_end_loopback(tx_queue, lb_tests);
 568                 kfree(state->skbs);
 569
 570                 if (begin_rc || end_rc) {
 571                         /* Wait a while to ensure there are no packets
 572                          * floating around after a failure. */
 573                         schedule_timeout_uninterruptible(HZ / 10);
 574                         return begin_rc ? begin_rc : end_rc;
 575                 }
 576         }
 577
 578         netif_dbg(efx, drv, efx->net_dev,
 579                   "TX queue %d passed %s loopback test with a burst length "
 580                   "of %d packets\n", tx_queue->queue, LOOPBACK_MODE(efx),
 581                   state->packet_count);
 582
 583         return 0;
 584 }
 585
 586 /* Wait for link up. On Falcon, we would prefer to rely on ef4_monitor, but
 587  * any contention on the mac lock (via e.g. ef4_mac_mcast_work) causes it
 588  * to delay and retry. Therefore, it's safer to just poll directly. Wait
 589  * for link up and any faults to dissipate. */
 590 static int ef4_wait_for_link(struct ef4_nic *efx)
 591 {
 592         struct ef4_link_state *link_state = &efx->link_state;
 593         int count, link_up_count = 0;
 594         bool link_up;
 595
 596         for (count = 0; count < 40; count++) {
 597                 schedule_timeout_uninterruptible(HZ / 10);
 598
 599                 if (efx->type->monitor != NULL) {
 600                         mutex_lock(&efx->mac_lock);
 601                         efx->type->monitor(efx);
 602                         mutex_unlock(&efx->mac_lock);
 603                 }
 604
 605                 mutex_lock(&efx->mac_lock);
 606                 link_up = link_state->up;
 607                 if (link_up)
 608                         link_up = !efx->type->check_mac_fault(efx);
 609                 mutex_unlock(&efx->mac_lock);
 610
 611                 if (link_up) {
 612                         if (++link_up_count == 2)
 613                                 return 0;
 614                 } else {
 615                         link_up_count = 0;
 616                 }
 617         }
 618
 619         return -ETIMEDOUT;
 620 }
 621
 622 static int ef4_test_loopbacks(struct ef4_nic *efx, struct ef4_self_tests *tests,
 623                               unsigned int loopback_modes)
 624 {
 625         enum ef4_loopback_mode mode;
 626         struct ef4_loopback_state *state;
 627         struct ef4_channel *channel =
 628                 ef4_get_channel(efx, efx->tx_channel_offset);
 629         struct ef4_tx_queue *tx_queue;
 630         int rc = 0;
 631
 632         /* Set the port loopback_selftest member. From this point on
 633          * all received packets will be dropped. Mark the state as
 634          * "flushing" so all inflight packets are dropped */
 635         state = kzalloc(sizeof(*state), GFP_KERNEL);
 636         if (state == NULL)
 637                 return -ENOMEM;
 638         BUG_ON(efx->loopback_selftest);
 639         state->flush = true;
 640         efx->loopback_selftest = state;
 641
 642         /* Test all supported loopback modes */
 643         for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) {
 644                 if (!(loopback_modes & (1 << mode)))
 645                         continue;
 646
 647                 /* Move the port into the specified loopback mode. */
 648                 state->flush = true;
 649                 mutex_lock(&efx->mac_lock);
 650                 efx->loopback_mode = mode;
 651                 rc = __ef4_reconfigure_port(efx);
 652                 mutex_unlock(&efx->mac_lock);
 653                 if (rc) {
 654                         netif_err(efx, drv, efx->net_dev,
 655                                   "unable to move into %s loopback\n",
 656                                   LOOPBACK_MODE(efx));
 657                         goto out;
 658                 }
 659
 660                 rc = ef4_wait_for_link(efx);
 661                 if (rc) {
 662                         netif_err(efx, drv, efx->net_dev,
 663                                   "loopback %s never came up\n",
 664                                   LOOPBACK_MODE(efx));
 665                         goto out;
 666                 }
 667
 668                 /* Test all enabled types of TX queue */
 669                 ef4_for_each_channel_tx_queue(tx_queue, channel) {
 670                         state->offload_csum = (tx_queue->queue &
 671                                                EF4_TXQ_TYPE_OFFLOAD);
 672                         rc = ef4_test_loopback(tx_queue,
 673                                                &tests->loopback[mode]);
 674                         if (rc)
 675                                 goto out;
 676                 }
 677         }
 678
 679  out:
 680         /* Remove the flush. The caller will remove the loopback setting */
 681         state->flush = true;
 682         efx->loopback_selftest = NULL;
 683         wmb();
 684         kfree(state);
 685
 686         if (rc == -EPERM)
 687                 rc = 0;
 688
 689         return rc;
 690 }
 691
 692 /**************************************************************************
 693  *
 694  * Entry point
 695  *
 696  *************************************************************************/
 697
 698 int ef4_selftest(struct ef4_nic *efx, struct ef4_self_tests *tests,
 699                  unsigned flags)
 700 {
 701         enum ef4_loopback_mode loopback_mode = efx->loopback_mode;
 702         int phy_mode = efx->phy_mode;
 703         int rc_test = 0, rc_reset, rc;
 704
 705         ef4_selftest_async_cancel(efx);
 706
 707         /* Online (i.e. non-disruptive) testing
 708          * This checks interrupt generation, event delivery and PHY presence. */
 709
 710         rc = ef4_test_phy_alive(efx, tests);
 711         if (rc && !rc_test)
 712                 rc_test = rc;
 713
 714         rc = ef4_test_nvram(efx, tests);
 715         if (rc && !rc_test)
 716                 rc_test = rc;
 717
 718         rc = ef4_test_interrupts(efx, tests);
 719         if (rc && !rc_test)
 720                 rc_test = rc;
 721
 722         rc = ef4_test_eventq_irq(efx, tests);
 723         if (rc && !rc_test)
 724                 rc_test = rc;
 725
 726         if (rc_test)
 727                 return rc_test;
 728
 729         if (!(flags & ETH_TEST_FL_OFFLINE))
 730                 return ef4_test_phy(efx, tests, flags);
 731
 732         /* Offline (i.e. disruptive) testing
 733          * This checks MAC and PHY loopback on the specified port. */
 734
 735         /* Detach the device so the kernel doesn't transmit during the
 736          * loopback test and the watchdog timeout doesn't fire.
 737          */
 738         ef4_device_detach_sync(efx);
 739
 740         if (efx->type->test_chip) {
 741                 rc_reset = efx->type->test_chip(efx, tests);
 742                 if (rc_reset) {
 743                         netif_err(efx, hw, efx->net_dev,
 744                                   "Unable to recover from chip test\n");
 745                         ef4_schedule_reset(efx, RESET_TYPE_DISABLE);
 746                         return rc_reset;
 747                 }
 748
 749                 if ((tests->memory < 0 || tests->registers < 0) && !rc_test)
 750                         rc_test = -EIO;
 751         }
 752
 753         /* Ensure that the phy is powered and out of loopback
 754          * for the bist and loopback tests */
 755         mutex_lock(&efx->mac_lock);
 756         efx->phy_mode &= ~PHY_MODE_LOW_POWER;
 757         efx->loopback_mode = LOOPBACK_NONE;
 758         __ef4_reconfigure_port(efx);
 759         mutex_unlock(&efx->mac_lock);
 760
 761         rc = ef4_test_phy(efx, tests, flags);
 762         if (rc && !rc_test)
 763                 rc_test = rc;
 764
 765         rc = ef4_test_loopbacks(efx, tests, efx->loopback_modes);
 766         if (rc && !rc_test)
 767                 rc_test = rc;
 768
 769         /* restore the PHY to the previous state */
 770         mutex_lock(&efx->mac_lock);
 771         efx->phy_mode = phy_mode;
 772         efx->loopback_mode = loopback_mode;
 773         __ef4_reconfigure_port(efx);
 774         mutex_unlock(&efx->mac_lock);
 775
 776         netif_device_attach(efx->net_dev);
 777
 778         return rc_test;
 779 }
 780
 781 void ef4_selftest_async_start(struct ef4_nic *efx)
 782 {
 783         struct ef4_channel *channel;
 784
 785         ef4_for_each_channel(channel, efx)
 786                 ef4_nic_event_test_start(channel);
 787         schedule_delayed_work(&efx->selftest_work, IRQ_TIMEOUT);
 788 }
 789
 790 void ef4_selftest_async_cancel(struct ef4_nic *efx)
 791 {
 792         cancel_delayed_work_sync(&efx->selftest_work);
 793 }
 794
 795 void ef4_selftest_async_work(struct work_struct *data)
 796 {
 797         struct ef4_nic *efx = container_of(data, struct ef4_nic,
 798                                            selftest_work.work);
 799         struct ef4_channel *channel;
 800         int cpu;
 801
 802         ef4_for_each_channel(channel, efx) {
 803                 cpu = ef4_nic_event_test_irq_cpu(channel);
 804                 if (cpu < 0)
 805                         netif_err(efx, ifup, efx->net_dev,
 806                                   "channel %d failed to trigger an interrupt\n",
 807                                   channel->channel);
 808                 else
 809                         netif_dbg(efx, ifup, efx->net_dev,
 810                                   "channel %d triggered interrupt on CPU %d\n",
 811                                   channel->channel, cpu);
 812         }
 813 }