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 "efx_common.h" 22 #include "efx_channels.h" 23 #include "nic.h" 24 #include "mcdi_port_common.h" 25 #include "selftest.h" 26 #include "workarounds.h" 27 28 /* IRQ latency can be enormous because: 29 * - All IRQs may be disabled on a CPU for a *long* time by e.g. a 30 * slow serial console or an old IDE driver doing error recovery 31 * - The PREEMPT_RT patches mostly deal with this, but also allow a 32 * tasklet or normal task to be given higher priority than our IRQ 33 * threads 34 * Try to avoid blaming the hardware for this. 35 */ 36 #define IRQ_TIMEOUT HZ 37 38 /* 39 * Loopback test packet structure 40 * 41 * The self-test should stress every RSS vector. 42 */ 43 struct efx_loopback_payload { 44 char pad[2]; /* Ensures ip is 4-byte aligned */ 45 struct_group_attr(packet, __packed, 46 struct ethhdr header; 47 struct iphdr ip; 48 struct udphdr udp; 49 __be16 iteration; 50 char msg[64]; 51 ); 52 } __packed __aligned(4); 53 #define EFX_LOOPBACK_PAYLOAD_LEN \ 54 sizeof_field(struct efx_loopback_payload, packet) 55 56 /* Loopback test source MAC address */ 57 static const u8 payload_source[ETH_ALEN] __aligned(2) = { 58 0x00, 0x0f, 0x53, 0x1b, 0x1b, 0x1b, 59 }; 60 61 static const char payload_msg[] = 62 "Hello world! This is an Efx loopback test in progress!"; 63 64 /* Interrupt mode names */ 65 static const unsigned int efx_interrupt_mode_max = EFX_INT_MODE_MAX; 66 static const char *const efx_interrupt_mode_names[] = { 67 [EFX_INT_MODE_MSIX] = "MSI-X", 68 [EFX_INT_MODE_MSI] = "MSI", 69 [EFX_INT_MODE_LEGACY] = "legacy", 70 }; 71 #define INT_MODE(efx) \ 72 STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_interrupt_mode) 73 74 /** 75 * struct efx_loopback_state - persistent state during a loopback selftest 76 * @flush: Drop all packets in efx_loopback_rx_packet 77 * @packet_count: Number of packets being used in this test 78 * @skbs: An array of skbs transmitted 79 * @offload_csum: Checksums are being offloaded 80 * @rx_good: RX good packet count 81 * @rx_bad: RX bad packet count 82 * @payload: Payload used in tests 83 */ 84 struct efx_loopback_state { 85 bool flush; 86 int packet_count; 87 struct sk_buff **skbs; 88 bool offload_csum; 89 atomic_t rx_good; 90 atomic_t rx_bad; 91 struct efx_loopback_payload payload; 92 }; 93 94 /* How long to wait for all the packets to arrive (in ms) */ 95 #define LOOPBACK_TIMEOUT_MS 1000 96 97 /************************************************************************** 98 * 99 * MII, NVRAM and register tests 100 * 101 **************************************************************************/ 102 103 static int efx_test_phy_alive(struct efx_nic *efx, struct efx_self_tests *tests) 104 { 105 int rc = 0; 106 107 rc = efx_mcdi_phy_test_alive(efx); 108 tests->phy_alive = rc ? -1 : 1; 109 110 return rc; 111 } 112 113 static int efx_test_nvram(struct efx_nic *efx, struct efx_self_tests *tests) 114 { 115 int rc = 0; 116 117 if (efx->type->test_nvram) { 118 rc = efx->type->test_nvram(efx); 119 if (rc == -EPERM) 120 rc = 0; 121 else 122 tests->nvram = rc ? -1 : 1; 123 } 124 125 return rc; 126 } 127 128 /************************************************************************** 129 * 130 * Interrupt and event queue testing 131 * 132 **************************************************************************/ 133 134 /* Test generation and receipt of interrupts */ 135 static int efx_test_interrupts(struct efx_nic *efx, 136 struct efx_self_tests *tests) 137 { 138 unsigned long timeout, wait; 139 int cpu; 140 int rc; 141 142 netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n"); 143 tests->interrupt = -1; 144 145 rc = efx_nic_irq_test_start(efx); 146 if (rc == -ENOTSUPP) { 147 netif_dbg(efx, drv, efx->net_dev, 148 "direct interrupt testing not supported\n"); 149 tests->interrupt = 0; 150 return 0; 151 } 152 153 timeout = jiffies + IRQ_TIMEOUT; 154 wait = 1; 155 156 /* Wait for arrival of test interrupt. */ 157 netif_dbg(efx, drv, efx->net_dev, "waiting for test interrupt\n"); 158 do { 159 schedule_timeout_uninterruptible(wait); 160 cpu = efx_nic_irq_test_irq_cpu(efx); 161 if (cpu >= 0) 162 goto success; 163 wait *= 2; 164 } while (time_before(jiffies, timeout)); 165 166 netif_err(efx, drv, efx->net_dev, "timed out waiting for interrupt\n"); 167 return -ETIMEDOUT; 168 169 success: 170 netif_dbg(efx, drv, efx->net_dev, "%s test interrupt seen on CPU%d\n", 171 INT_MODE(efx), cpu); 172 tests->interrupt = 1; 173 return 0; 174 } 175 176 /* Test generation and receipt of interrupting events */ 177 static int efx_test_eventq_irq(struct efx_nic *efx, 178 struct efx_self_tests *tests) 179 { 180 struct efx_channel *channel; 181 unsigned int read_ptr[EFX_MAX_CHANNELS]; 182 unsigned long napi_ran = 0, dma_pend = 0, int_pend = 0; 183 unsigned long timeout, wait; 184 185 BUILD_BUG_ON(EFX_MAX_CHANNELS > BITS_PER_LONG); 186 187 efx_for_each_channel(channel, efx) { 188 read_ptr[channel->channel] = channel->eventq_read_ptr; 189 set_bit(channel->channel, &dma_pend); 190 set_bit(channel->channel, &int_pend); 191 efx_nic_event_test_start(channel); 192 } 193 194 timeout = jiffies + IRQ_TIMEOUT; 195 wait = 1; 196 197 /* Wait for arrival of interrupts. NAPI processing may or may 198 * not complete in time, but we can cope in any case. 199 */ 200 do { 201 schedule_timeout_uninterruptible(wait); 202 203 efx_for_each_channel(channel, efx) { 204 efx_stop_eventq(channel); 205 if (channel->eventq_read_ptr != 206 read_ptr[channel->channel]) { 207 set_bit(channel->channel, &napi_ran); 208 clear_bit(channel->channel, &dma_pend); 209 clear_bit(channel->channel, &int_pend); 210 } else { 211 if (efx_nic_event_present(channel)) 212 clear_bit(channel->channel, &dma_pend); 213 if (efx_nic_event_test_irq_cpu(channel) >= 0) 214 clear_bit(channel->channel, &int_pend); 215 } 216 efx_start_eventq(channel); 217 } 218 219 wait *= 2; 220 } while ((dma_pend || int_pend) && time_before(jiffies, timeout)); 221 222 efx_for_each_channel(channel, efx) { 223 bool dma_seen = !test_bit(channel->channel, &dma_pend); 224 bool int_seen = !test_bit(channel->channel, &int_pend); 225 226 tests->eventq_dma[channel->channel] = dma_seen ? 1 : -1; 227 tests->eventq_int[channel->channel] = int_seen ? 1 : -1; 228 229 if (dma_seen && int_seen) { 230 netif_dbg(efx, drv, efx->net_dev, 231 "channel %d event queue passed (with%s NAPI)\n", 232 channel->channel, 233 test_bit(channel->channel, &napi_ran) ? 234 "" : "out"); 235 } else { 236 /* Report failure and whether either interrupt or DMA 237 * worked 238 */ 239 netif_err(efx, drv, efx->net_dev, 240 "channel %d timed out waiting for event queue\n", 241 channel->channel); 242 if (int_seen) 243 netif_err(efx, drv, efx->net_dev, 244 "channel %d saw interrupt " 245 "during event queue test\n", 246 channel->channel); 247 if (dma_seen) 248 netif_err(efx, drv, efx->net_dev, 249 "channel %d event was generated, but " 250 "failed to trigger an interrupt\n", 251 channel->channel); 252 } 253 } 254 255 return (dma_pend || int_pend) ? -ETIMEDOUT : 0; 256 } 257 258 static int efx_test_phy(struct efx_nic *efx, struct efx_self_tests *tests, 259 unsigned flags) 260 { 261 int rc; 262 263 mutex_lock(&efx->mac_lock); 264 rc = efx_mcdi_phy_run_tests(efx, tests->phy_ext, flags); 265 mutex_unlock(&efx->mac_lock); 266 if (rc == -EPERM) 267 rc = 0; 268 else 269 netif_info(efx, drv, efx->net_dev, 270 "%s phy selftest\n", rc ? "Failed" : "Passed"); 271 272 return rc; 273 } 274 275 /************************************************************************** 276 * 277 * Loopback testing 278 * NB Only one loopback test can be executing concurrently. 279 * 280 **************************************************************************/ 281 282 /* Loopback test RX callback 283 * This is called for each received packet during loopback testing. 284 */ 285 void efx_loopback_rx_packet(struct efx_nic *efx, 286 const char *buf_ptr, int pkt_len) 287 { 288 struct efx_loopback_state *state = efx->loopback_selftest; 289 struct efx_loopback_payload received; 290 struct efx_loopback_payload *payload; 291 292 BUG_ON(!buf_ptr); 293 294 /* If we are just flushing, then drop the packet */ 295 if ((state == NULL) || state->flush) 296 return; 297 298 payload = &state->payload; 299 300 memcpy(&received.packet, buf_ptr, 301 min_t(int, pkt_len, EFX_LOOPBACK_PAYLOAD_LEN)); 302 received.ip.saddr = payload->ip.saddr; 303 if (state->offload_csum) 304 received.ip.check = payload->ip.check; 305 306 /* Check that header exists */ 307 if (pkt_len < sizeof(received.header)) { 308 netif_err(efx, drv, efx->net_dev, 309 "saw runt RX packet (length %d) in %s loopback " 310 "test\n", pkt_len, LOOPBACK_MODE(efx)); 311 goto err; 312 } 313 314 /* Check that the ethernet header exists */ 315 if (memcmp(&received.header, &payload->header, ETH_HLEN) != 0) { 316 netif_err(efx, drv, efx->net_dev, 317 "saw non-loopback RX packet in %s loopback test\n", 318 LOOPBACK_MODE(efx)); 319 goto err; 320 } 321 322 /* Check packet length */ 323 if (pkt_len != EFX_LOOPBACK_PAYLOAD_LEN) { 324 netif_err(efx, drv, efx->net_dev, 325 "saw incorrect RX packet length %d (wanted %d) in " 326 "%s loopback test\n", pkt_len, 327 (int)EFX_LOOPBACK_PAYLOAD_LEN, LOOPBACK_MODE(efx)); 328 goto err; 329 } 330 331 /* Check that IP header matches */ 332 if (memcmp(&received.ip, &payload->ip, sizeof(payload->ip)) != 0) { 333 netif_err(efx, drv, efx->net_dev, 334 "saw corrupted IP header in %s loopback test\n", 335 LOOPBACK_MODE(efx)); 336 goto err; 337 } 338 339 /* Check that msg and padding matches */ 340 if (memcmp(&received.msg, &payload->msg, sizeof(received.msg)) != 0) { 341 netif_err(efx, drv, efx->net_dev, 342 "saw corrupted RX packet in %s loopback test\n", 343 LOOPBACK_MODE(efx)); 344 goto err; 345 } 346 347 /* Check that iteration matches */ 348 if (received.iteration != payload->iteration) { 349 netif_err(efx, drv, efx->net_dev, 350 "saw RX packet from iteration %d (wanted %d) in " 351 "%s loopback test\n", ntohs(received.iteration), 352 ntohs(payload->iteration), LOOPBACK_MODE(efx)); 353 goto err; 354 } 355 356 /* Increase correct RX count */ 357 netif_vdbg(efx, drv, efx->net_dev, 358 "got loopback RX in %s loopback test\n", LOOPBACK_MODE(efx)); 359 360 atomic_inc(&state->rx_good); 361 return; 362 363 err: 364 #ifdef DEBUG 365 if (atomic_read(&state->rx_bad) == 0) { 366 netif_err(efx, drv, efx->net_dev, "received packet:\n"); 367 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1, 368 buf_ptr, pkt_len, 0); 369 netif_err(efx, drv, efx->net_dev, "expected packet:\n"); 370 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1, 371 &state->payload.packet, EFX_LOOPBACK_PAYLOAD_LEN, 372 0); 373 } 374 #endif 375 atomic_inc(&state->rx_bad); 376 } 377 378 /* Initialise an efx_selftest_state for a new iteration */ 379 static void efx_iterate_state(struct efx_nic *efx) 380 { 381 struct efx_loopback_state *state = efx->loopback_selftest; 382 struct net_device *net_dev = efx->net_dev; 383 struct efx_loopback_payload *payload = &state->payload; 384 385 /* Initialise the layerII header */ 386 ether_addr_copy((u8 *)&payload->header.h_dest, net_dev->dev_addr); 387 ether_addr_copy((u8 *)&payload->header.h_source, payload_source); 388 payload->header.h_proto = htons(ETH_P_IP); 389 390 /* saddr set later and used as incrementing count */ 391 payload->ip.daddr = htonl(INADDR_LOOPBACK); 392 payload->ip.ihl = 5; 393 payload->ip.check = (__force __sum16) htons(0xdead); 394 payload->ip.tot_len = htons(sizeof(*payload) - 395 offsetof(struct efx_loopback_payload, ip)); 396 payload->ip.version = IPVERSION; 397 payload->ip.protocol = IPPROTO_UDP; 398 399 /* Initialise udp header */ 400 payload->udp.source = 0; 401 payload->udp.len = htons(sizeof(*payload) - 402 offsetof(struct efx_loopback_payload, udp)); 403 payload->udp.check = 0; /* checksum ignored */ 404 405 /* Fill out payload */ 406 payload->iteration = htons(ntohs(payload->iteration) + 1); 407 memcpy(&payload->msg, payload_msg, sizeof(payload_msg)); 408 409 /* Fill out remaining state members */ 410 atomic_set(&state->rx_good, 0); 411 atomic_set(&state->rx_bad, 0); 412 smp_wmb(); 413 } 414 415 static int efx_begin_loopback(struct efx_tx_queue *tx_queue) 416 { 417 struct efx_nic *efx = tx_queue->efx; 418 struct efx_loopback_state *state = efx->loopback_selftest; 419 struct efx_loopback_payload *payload; 420 struct sk_buff *skb; 421 int i; 422 netdev_tx_t rc; 423 424 /* Transmit N copies of buffer */ 425 for (i = 0; i < state->packet_count; i++) { 426 /* Allocate an skb, holding an extra reference for 427 * transmit completion counting */ 428 skb = alloc_skb(EFX_LOOPBACK_PAYLOAD_LEN, GFP_KERNEL); 429 if (!skb) 430 return -ENOMEM; 431 state->skbs[i] = skb; 432 skb_get(skb); 433 434 /* Copy the payload in, incrementing the source address to 435 * exercise the rss vectors */ 436 payload = skb_put(skb, sizeof(state->payload)); 437 memcpy(payload, &state->payload, sizeof(state->payload)); 438 payload->ip.saddr = htonl(INADDR_LOOPBACK | (i << 2)); 439 /* Strip off the leading padding */ 440 skb_pull(skb, offsetof(struct efx_loopback_payload, header)); 441 /* Strip off the trailing padding */ 442 skb_trim(skb, EFX_LOOPBACK_PAYLOAD_LEN); 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 = efx_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->label, 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 efx_poll_loopback(struct efx_nic *efx) 469 { 470 struct efx_loopback_state *state = efx->loopback_selftest; 471 472 return atomic_read(&state->rx_good) == state->packet_count; 473 } 474 475 static int efx_end_loopback(struct efx_tx_queue *tx_queue, 476 struct efx_loopback_self_tests *lb_tests) 477 { 478 struct efx_nic *efx = tx_queue->efx; 479 struct efx_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->label, 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->label, 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->label] += state->packet_count; 526 lb_tests->tx_done[tx_queue->label] += 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 efx_test_loopback(struct efx_tx_queue *tx_queue, 535 struct efx_loopback_self_tests *lb_tests) 536 { 537 struct efx_nic *efx = tx_queue->efx; 538 struct efx_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 (hw %d) testing %s loopback with %d packets\n", 553 tx_queue->label, tx_queue->queue, LOOPBACK_MODE(efx), 554 state->packet_count); 555 556 efx_iterate_state(efx); 557 begin_rc = efx_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 (!efx_poll_loopback(efx)) { 563 msleep(LOOPBACK_TIMEOUT_MS); 564 efx_poll_loopback(efx); 565 } 566 567 end_rc = efx_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->label, LOOPBACK_MODE(efx), 581 state->packet_count); 582 583 return 0; 584 } 585 586 static int efx_wait_for_link(struct efx_nic *efx) 587 { 588 struct efx_link_state *link_state = &efx->link_state; 589 int count, link_up_count = 0; 590 bool link_up; 591 592 for (count = 0; count < 40; count++) { 593 schedule_timeout_uninterruptible(HZ / 10); 594 595 if (efx->type->monitor != NULL) { 596 mutex_lock(&efx->mac_lock); 597 efx->type->monitor(efx); 598 mutex_unlock(&efx->mac_lock); 599 } 600 601 mutex_lock(&efx->mac_lock); 602 link_up = link_state->up; 603 if (link_up) 604 link_up = !efx->type->check_mac_fault(efx); 605 mutex_unlock(&efx->mac_lock); 606 607 if (link_up) { 608 if (++link_up_count == 2) 609 return 0; 610 } else { 611 link_up_count = 0; 612 } 613 } 614 615 return -ETIMEDOUT; 616 } 617 618 static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests, 619 unsigned int loopback_modes) 620 { 621 enum efx_loopback_mode mode; 622 struct efx_loopback_state *state; 623 struct efx_channel *channel = 624 efx_get_channel(efx, efx->tx_channel_offset); 625 struct efx_tx_queue *tx_queue; 626 int rc = 0; 627 628 /* Set the port loopback_selftest member. From this point on 629 * all received packets will be dropped. Mark the state as 630 * "flushing" so all inflight packets are dropped */ 631 state = kzalloc(sizeof(*state), GFP_KERNEL); 632 if (state == NULL) 633 return -ENOMEM; 634 BUG_ON(efx->loopback_selftest); 635 state->flush = true; 636 efx->loopback_selftest = state; 637 638 /* Test all supported loopback modes */ 639 for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) { 640 if (!(loopback_modes & (1 << mode))) 641 continue; 642 643 /* Move the port into the specified loopback mode. */ 644 state->flush = true; 645 mutex_lock(&efx->mac_lock); 646 efx->loopback_mode = mode; 647 rc = __efx_reconfigure_port(efx); 648 mutex_unlock(&efx->mac_lock); 649 if (rc) { 650 netif_err(efx, drv, efx->net_dev, 651 "unable to move into %s loopback\n", 652 LOOPBACK_MODE(efx)); 653 goto out; 654 } 655 656 rc = efx_wait_for_link(efx); 657 if (rc) { 658 netif_err(efx, drv, efx->net_dev, 659 "loopback %s never came up\n", 660 LOOPBACK_MODE(efx)); 661 goto out; 662 } 663 664 /* Test all enabled types of TX queue */ 665 efx_for_each_channel_tx_queue(tx_queue, channel) { 666 state->offload_csum = (tx_queue->type & 667 EFX_TXQ_TYPE_OUTER_CSUM); 668 rc = efx_test_loopback(tx_queue, 669 &tests->loopback[mode]); 670 if (rc) 671 goto out; 672 } 673 } 674 675 out: 676 /* Remove the flush. The caller will remove the loopback setting */ 677 state->flush = true; 678 efx->loopback_selftest = NULL; 679 wmb(); 680 kfree(state); 681 682 if (rc == -EPERM) 683 rc = 0; 684 685 return rc; 686 } 687 688 /************************************************************************** 689 * 690 * Entry point 691 * 692 *************************************************************************/ 693 694 int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests, 695 unsigned flags) 696 { 697 enum efx_loopback_mode loopback_mode = efx->loopback_mode; 698 int phy_mode = efx->phy_mode; 699 int rc_test = 0, rc_reset, rc; 700 701 efx_selftest_async_cancel(efx); 702 703 /* Online (i.e. non-disruptive) testing 704 * This checks interrupt generation, event delivery and PHY presence. */ 705 706 rc = efx_test_phy_alive(efx, tests); 707 if (rc && !rc_test) 708 rc_test = rc; 709 710 rc = efx_test_nvram(efx, tests); 711 if (rc && !rc_test) 712 rc_test = rc; 713 714 rc = efx_test_interrupts(efx, tests); 715 if (rc && !rc_test) 716 rc_test = rc; 717 718 rc = efx_test_eventq_irq(efx, tests); 719 if (rc && !rc_test) 720 rc_test = rc; 721 722 if (rc_test) 723 return rc_test; 724 725 if (!(flags & ETH_TEST_FL_OFFLINE)) 726 return efx_test_phy(efx, tests, flags); 727 728 /* Offline (i.e. disruptive) testing 729 * This checks MAC and PHY loopback on the specified port. */ 730 731 /* Detach the device so the kernel doesn't transmit during the 732 * loopback test and the watchdog timeout doesn't fire. 733 */ 734 efx_device_detach_sync(efx); 735 736 if (efx->type->test_chip) { 737 rc_reset = efx->type->test_chip(efx, tests); 738 if (rc_reset) { 739 netif_err(efx, hw, efx->net_dev, 740 "Unable to recover from chip test\n"); 741 efx_schedule_reset(efx, RESET_TYPE_DISABLE); 742 return rc_reset; 743 } 744 745 if ((tests->memory < 0 || tests->registers < 0) && !rc_test) 746 rc_test = -EIO; 747 } 748 749 /* Ensure that the phy is powered and out of loopback 750 * for the bist and loopback tests */ 751 mutex_lock(&efx->mac_lock); 752 efx->phy_mode &= ~PHY_MODE_LOW_POWER; 753 efx->loopback_mode = LOOPBACK_NONE; 754 __efx_reconfigure_port(efx); 755 mutex_unlock(&efx->mac_lock); 756 757 rc = efx_test_phy(efx, tests, flags); 758 if (rc && !rc_test) 759 rc_test = rc; 760 761 rc = efx_test_loopbacks(efx, tests, efx->loopback_modes); 762 if (rc && !rc_test) 763 rc_test = rc; 764 765 /* restore the PHY to the previous state */ 766 mutex_lock(&efx->mac_lock); 767 efx->phy_mode = phy_mode; 768 efx->loopback_mode = loopback_mode; 769 __efx_reconfigure_port(efx); 770 mutex_unlock(&efx->mac_lock); 771 772 efx_device_attach_if_not_resetting(efx); 773 774 return rc_test; 775 } 776 777 void efx_selftest_async_start(struct efx_nic *efx) 778 { 779 struct efx_channel *channel; 780 781 efx_for_each_channel(channel, efx) 782 efx_nic_event_test_start(channel); 783 schedule_delayed_work(&efx->selftest_work, IRQ_TIMEOUT); 784 } 785 786 void efx_selftest_async_cancel(struct efx_nic *efx) 787 { 788 cancel_delayed_work_sync(&efx->selftest_work); 789 } 790 791 static void efx_selftest_async_work(struct work_struct *data) 792 { 793 struct efx_nic *efx = container_of(data, struct efx_nic, 794 selftest_work.work); 795 struct efx_channel *channel; 796 int cpu; 797 798 efx_for_each_channel(channel, efx) { 799 cpu = efx_nic_event_test_irq_cpu(channel); 800 if (cpu < 0) 801 netif_err(efx, ifup, efx->net_dev, 802 "channel %d failed to trigger an interrupt\n", 803 channel->channel); 804 else 805 netif_dbg(efx, ifup, efx->net_dev, 806 "channel %d triggered interrupt on CPU %d\n", 807 channel->channel, cpu); 808 } 809 } 810 811 void efx_selftest_async_init(struct efx_nic *efx) 812 { 813 INIT_DELAYED_WORK(&efx->selftest_work, efx_selftest_async_work); 814 } 815