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