1 /**************************************************************************** 2 * Driver for Solarflare Solarstorm network controllers and boards 3 * Copyright 2005-2006 Fen Systems Ltd. 4 * Copyright 2006-2010 Solarflare Communications Inc. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published 8 * by the Free Software Foundation, incorporated herein by reference. 9 */ 10 11 #include <linux/netdevice.h> 12 #include <linux/module.h> 13 #include <linux/delay.h> 14 #include <linux/kernel_stat.h> 15 #include <linux/pci.h> 16 #include <linux/ethtool.h> 17 #include <linux/ip.h> 18 #include <linux/in.h> 19 #include <linux/udp.h> 20 #include <linux/rtnetlink.h> 21 #include <linux/slab.h> 22 #include "net_driver.h" 23 #include "efx.h" 24 #include "nic.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, and unfortunately 42 * Falcon only performs RSS on TCP/UDP packets. 43 */ 44 struct efx_loopback_payload { 45 struct ethhdr header; 46 struct iphdr ip; 47 struct udphdr udp; 48 __be16 iteration; 49 const char msg[64]; 50 } __packed; 51 52 /* Loopback test source MAC address */ 53 static const unsigned char payload_source[ETH_ALEN] = { 54 0x00, 0x0f, 0x53, 0x1b, 0x1b, 0x1b, 55 }; 56 57 static const char payload_msg[] = 58 "Hello world! This is an Efx loopback test in progress!"; 59 60 /* Interrupt mode names */ 61 static const unsigned int efx_interrupt_mode_max = EFX_INT_MODE_MAX; 62 static const char *const efx_interrupt_mode_names[] = { 63 [EFX_INT_MODE_MSIX] = "MSI-X", 64 [EFX_INT_MODE_MSI] = "MSI", 65 [EFX_INT_MODE_LEGACY] = "legacy", 66 }; 67 #define INT_MODE(efx) \ 68 STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_interrupt_mode) 69 70 /** 71 * efx_loopback_state - persistent state during a loopback selftest 72 * @flush: Drop all packets in efx_loopback_rx_packet 73 * @packet_count: Number of packets being used in this test 74 * @skbs: An array of skbs transmitted 75 * @offload_csum: Checksums are being offloaded 76 * @rx_good: RX good packet count 77 * @rx_bad: RX bad packet count 78 * @payload: Payload used in tests 79 */ 80 struct efx_loopback_state { 81 bool flush; 82 int packet_count; 83 struct sk_buff **skbs; 84 bool offload_csum; 85 atomic_t rx_good; 86 atomic_t rx_bad; 87 struct efx_loopback_payload payload; 88 }; 89 90 /* How long to wait for all the packets to arrive (in ms) */ 91 #define LOOPBACK_TIMEOUT_MS 1000 92 93 /************************************************************************** 94 * 95 * MII, NVRAM and register tests 96 * 97 **************************************************************************/ 98 99 static int efx_test_phy_alive(struct efx_nic *efx, struct efx_self_tests *tests) 100 { 101 int rc = 0; 102 103 if (efx->phy_op->test_alive) { 104 rc = efx->phy_op->test_alive(efx); 105 tests->phy_alive = rc ? -1 : 1; 106 } 107 108 return rc; 109 } 110 111 static int efx_test_nvram(struct efx_nic *efx, struct efx_self_tests *tests) 112 { 113 int rc = 0; 114 115 if (efx->type->test_nvram) { 116 rc = efx->type->test_nvram(efx); 117 tests->nvram = rc ? -1 : 1; 118 } 119 120 return rc; 121 } 122 123 static int efx_test_chip(struct efx_nic *efx, struct efx_self_tests *tests) 124 { 125 int rc = 0; 126 127 /* Test register access */ 128 if (efx->type->test_registers) { 129 rc = efx->type->test_registers(efx); 130 tests->registers = rc ? -1 : 1; 131 } 132 133 return rc; 134 } 135 136 /************************************************************************** 137 * 138 * Interrupt and event queue testing 139 * 140 **************************************************************************/ 141 142 /* Test generation and receipt of interrupts */ 143 static int efx_test_interrupts(struct efx_nic *efx, 144 struct efx_self_tests *tests) 145 { 146 unsigned long timeout, wait; 147 int cpu; 148 149 netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n"); 150 tests->interrupt = -1; 151 152 efx_nic_irq_test_start(efx); 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 napi_disable(&channel->napi_str); 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 napi_enable(&channel->napi_str); 217 efx_nic_eventq_read_ack(channel); 218 } 219 220 wait *= 2; 221 } while ((dma_pend || int_pend) && time_before(jiffies, timeout)); 222 223 efx_for_each_channel(channel, efx) { 224 bool dma_seen = !test_bit(channel->channel, &dma_pend); 225 bool int_seen = !test_bit(channel->channel, &int_pend); 226 227 tests->eventq_dma[channel->channel] = dma_seen ? 1 : -1; 228 tests->eventq_int[channel->channel] = int_seen ? 1 : -1; 229 230 if (dma_seen && int_seen) { 231 netif_dbg(efx, drv, efx->net_dev, 232 "channel %d event queue passed (with%s NAPI)\n", 233 channel->channel, 234 test_bit(channel->channel, &napi_ran) ? 235 "" : "out"); 236 } else { 237 /* Report failure and whether either interrupt or DMA 238 * worked 239 */ 240 netif_err(efx, drv, efx->net_dev, 241 "channel %d timed out waiting for event queue\n", 242 channel->channel); 243 if (int_seen) 244 netif_err(efx, drv, efx->net_dev, 245 "channel %d saw interrupt " 246 "during event queue test\n", 247 channel->channel); 248 if (dma_seen) 249 netif_err(efx, drv, efx->net_dev, 250 "channel %d event was generated, but " 251 "failed to trigger an interrupt\n", 252 channel->channel); 253 } 254 } 255 256 return (dma_pend || int_pend) ? -ETIMEDOUT : 0; 257 } 258 259 static int efx_test_phy(struct efx_nic *efx, struct efx_self_tests *tests, 260 unsigned flags) 261 { 262 int rc; 263 264 if (!efx->phy_op->run_tests) 265 return 0; 266 267 mutex_lock(&efx->mac_lock); 268 rc = efx->phy_op->run_tests(efx, tests->phy_ext, flags); 269 mutex_unlock(&efx->mac_lock); 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 efx_loopback_rx_packet(struct efx_nic *efx, 284 const char *buf_ptr, int pkt_len) 285 { 286 struct efx_loopback_state *state = efx->loopback_selftest; 287 struct efx_loopback_payload *received; 288 struct efx_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 efx_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 efx_selftest_state for a new iteration */ 375 static void efx_iterate_state(struct efx_nic *efx) 376 { 377 struct efx_loopback_state *state = efx->loopback_selftest; 378 struct net_device *net_dev = efx->net_dev; 379 struct efx_loopback_payload *payload = &state->payload; 380 381 /* Initialise the layerII header */ 382 memcpy(&payload->header.h_dest, net_dev->dev_addr, ETH_ALEN); 383 memcpy(&payload->header.h_source, &payload_source, ETH_ALEN); 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 = 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 efx_begin_loopback(struct efx_tx_queue *tx_queue) 411 { 412 struct efx_nic *efx = tx_queue->efx; 413 struct efx_loopback_state *state = efx->loopback_selftest; 414 struct efx_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 = ((struct efx_loopback_payload *) 432 skb_put(skb, sizeof(state->payload))); 433 memcpy(payload, &state->payload, sizeof(state->payload)); 434 payload->ip.saddr = htonl(INADDR_LOOPBACK | (i << 2)); 435 436 /* Ensure everything we've written is visible to the 437 * interrupt handler. */ 438 smp_wmb(); 439 440 netif_tx_lock_bh(efx->net_dev); 441 rc = efx_enqueue_skb(tx_queue, skb); 442 netif_tx_unlock_bh(efx->net_dev); 443 444 if (rc != NETDEV_TX_OK) { 445 netif_err(efx, drv, efx->net_dev, 446 "TX queue %d could not transmit packet %d of " 447 "%d in %s loopback test\n", tx_queue->queue, 448 i + 1, state->packet_count, 449 LOOPBACK_MODE(efx)); 450 451 /* Defer cleaning up the other skbs for the caller */ 452 kfree_skb(skb); 453 return -EPIPE; 454 } 455 } 456 457 return 0; 458 } 459 460 static int efx_poll_loopback(struct efx_nic *efx) 461 { 462 struct efx_loopback_state *state = efx->loopback_selftest; 463 struct efx_channel *channel; 464 465 /* NAPI polling is not enabled, so process channels 466 * synchronously */ 467 efx_for_each_channel(channel, efx) { 468 if (channel->work_pending) 469 efx_process_channel_now(channel); 470 } 471 return atomic_read(&state->rx_good) == state->packet_count; 472 } 473 474 static int efx_end_loopback(struct efx_tx_queue *tx_queue, 475 struct efx_loopback_self_tests *lb_tests) 476 { 477 struct efx_nic *efx = tx_queue->efx; 478 struct efx_loopback_state *state = efx->loopback_selftest; 479 struct sk_buff *skb; 480 int tx_done = 0, rx_good, rx_bad; 481 int i, rc = 0; 482 483 netif_tx_lock_bh(efx->net_dev); 484 485 /* Count the number of tx completions, and decrement the refcnt. Any 486 * skbs not already completed will be free'd when the queue is flushed */ 487 for (i = 0; i < state->packet_count; i++) { 488 skb = state->skbs[i]; 489 if (skb && !skb_shared(skb)) 490 ++tx_done; 491 dev_kfree_skb_any(skb); 492 } 493 494 netif_tx_unlock_bh(efx->net_dev); 495 496 /* Check TX completion and received packet counts */ 497 rx_good = atomic_read(&state->rx_good); 498 rx_bad = atomic_read(&state->rx_bad); 499 if (tx_done != state->packet_count) { 500 /* Don't free the skbs; they will be picked up on TX 501 * overflow or channel teardown. 502 */ 503 netif_err(efx, drv, efx->net_dev, 504 "TX queue %d saw only %d out of an expected %d " 505 "TX completion events in %s loopback test\n", 506 tx_queue->queue, tx_done, state->packet_count, 507 LOOPBACK_MODE(efx)); 508 rc = -ETIMEDOUT; 509 /* Allow to fall through so we see the RX errors as well */ 510 } 511 512 /* We may always be up to a flush away from our desired packet total */ 513 if (rx_good != state->packet_count) { 514 netif_dbg(efx, drv, efx->net_dev, 515 "TX queue %d saw only %d out of an expected %d " 516 "received packets in %s loopback test\n", 517 tx_queue->queue, rx_good, state->packet_count, 518 LOOPBACK_MODE(efx)); 519 rc = -ETIMEDOUT; 520 /* Fall through */ 521 } 522 523 /* Update loopback test structure */ 524 lb_tests->tx_sent[tx_queue->queue] += state->packet_count; 525 lb_tests->tx_done[tx_queue->queue] += tx_done; 526 lb_tests->rx_good += rx_good; 527 lb_tests->rx_bad += rx_bad; 528 529 return rc; 530 } 531 532 static int 533 efx_test_loopback(struct efx_tx_queue *tx_queue, 534 struct efx_loopback_self_tests *lb_tests) 535 { 536 struct efx_nic *efx = tx_queue->efx; 537 struct efx_loopback_state *state = efx->loopback_selftest; 538 int i, begin_rc, end_rc; 539 540 for (i = 0; i < 3; i++) { 541 /* Determine how many packets to send */ 542 state->packet_count = efx->txq_entries / 3; 543 state->packet_count = min(1 << (i << 2), state->packet_count); 544 state->skbs = kcalloc(state->packet_count, 545 sizeof(state->skbs[0]), GFP_KERNEL); 546 if (!state->skbs) 547 return -ENOMEM; 548 state->flush = false; 549 550 netif_dbg(efx, drv, efx->net_dev, 551 "TX queue %d testing %s loopback with %d packets\n", 552 tx_queue->queue, LOOPBACK_MODE(efx), 553 state->packet_count); 554 555 efx_iterate_state(efx); 556 begin_rc = efx_begin_loopback(tx_queue); 557 558 /* This will normally complete very quickly, but be 559 * prepared to wait much longer. */ 560 msleep(1); 561 if (!efx_poll_loopback(efx)) { 562 msleep(LOOPBACK_TIMEOUT_MS); 563 efx_poll_loopback(efx); 564 } 565 566 end_rc = efx_end_loopback(tx_queue, lb_tests); 567 kfree(state->skbs); 568 569 if (begin_rc || end_rc) { 570 /* Wait a while to ensure there are no packets 571 * floating around after a failure. */ 572 schedule_timeout_uninterruptible(HZ / 10); 573 return begin_rc ? begin_rc : end_rc; 574 } 575 } 576 577 netif_dbg(efx, drv, efx->net_dev, 578 "TX queue %d passed %s loopback test with a burst length " 579 "of %d packets\n", tx_queue->queue, LOOPBACK_MODE(efx), 580 state->packet_count); 581 582 return 0; 583 } 584 585 /* Wait for link up. On Falcon, we would prefer to rely on efx_monitor, but 586 * any contention on the mac lock (via e.g. efx_mac_mcast_work) causes it 587 * to delay and retry. Therefore, it's safer to just poll directly. Wait 588 * for link up and any faults to dissipate. */ 589 static int efx_wait_for_link(struct efx_nic *efx) 590 { 591 struct efx_link_state *link_state = &efx->link_state; 592 int count, link_up_count = 0; 593 bool link_up; 594 595 for (count = 0; count < 40; count++) { 596 schedule_timeout_uninterruptible(HZ / 10); 597 598 if (efx->type->monitor != NULL) { 599 mutex_lock(&efx->mac_lock); 600 efx->type->monitor(efx); 601 mutex_unlock(&efx->mac_lock); 602 } else { 603 struct efx_channel *channel = efx_get_channel(efx, 0); 604 if (channel->work_pending) 605 efx_process_channel_now(channel); 606 } 607 608 mutex_lock(&efx->mac_lock); 609 link_up = link_state->up; 610 if (link_up) 611 link_up = !efx->type->check_mac_fault(efx); 612 mutex_unlock(&efx->mac_lock); 613 614 if (link_up) { 615 if (++link_up_count == 2) 616 return 0; 617 } else { 618 link_up_count = 0; 619 } 620 } 621 622 return -ETIMEDOUT; 623 } 624 625 static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests, 626 unsigned int loopback_modes) 627 { 628 enum efx_loopback_mode mode; 629 struct efx_loopback_state *state; 630 struct efx_channel *channel = efx_get_channel(efx, 0); 631 struct efx_tx_queue *tx_queue; 632 int rc = 0; 633 634 /* Set the port loopback_selftest member. From this point on 635 * all received packets will be dropped. Mark the state as 636 * "flushing" so all inflight packets are dropped */ 637 state = kzalloc(sizeof(*state), GFP_KERNEL); 638 if (state == NULL) 639 return -ENOMEM; 640 BUG_ON(efx->loopback_selftest); 641 state->flush = true; 642 efx->loopback_selftest = state; 643 644 /* Test all supported loopback modes */ 645 for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) { 646 if (!(loopback_modes & (1 << mode))) 647 continue; 648 649 /* Move the port into the specified loopback mode. */ 650 state->flush = true; 651 mutex_lock(&efx->mac_lock); 652 efx->loopback_mode = mode; 653 rc = __efx_reconfigure_port(efx); 654 mutex_unlock(&efx->mac_lock); 655 if (rc) { 656 netif_err(efx, drv, efx->net_dev, 657 "unable to move into %s loopback\n", 658 LOOPBACK_MODE(efx)); 659 goto out; 660 } 661 662 rc = efx_wait_for_link(efx); 663 if (rc) { 664 netif_err(efx, drv, efx->net_dev, 665 "loopback %s never came up\n", 666 LOOPBACK_MODE(efx)); 667 goto out; 668 } 669 670 /* Test all enabled types of TX queue */ 671 efx_for_each_channel_tx_queue(tx_queue, channel) { 672 state->offload_csum = (tx_queue->queue & 673 EFX_TXQ_TYPE_OFFLOAD); 674 rc = efx_test_loopback(tx_queue, 675 &tests->loopback[mode]); 676 if (rc) 677 goto out; 678 } 679 } 680 681 out: 682 /* Remove the flush. The caller will remove the loopback setting */ 683 state->flush = true; 684 efx->loopback_selftest = NULL; 685 wmb(); 686 kfree(state); 687 688 return rc; 689 } 690 691 /************************************************************************** 692 * 693 * Entry point 694 * 695 *************************************************************************/ 696 697 int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests, 698 unsigned flags) 699 { 700 enum efx_loopback_mode loopback_mode = efx->loopback_mode; 701 int phy_mode = efx->phy_mode; 702 enum reset_type reset_method = RESET_TYPE_INVISIBLE; 703 int rc_test = 0, rc_reset = 0, rc; 704 705 efx_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 = efx_test_phy_alive(efx, tests); 711 if (rc && !rc_test) 712 rc_test = rc; 713 714 rc = efx_test_nvram(efx, tests); 715 if (rc && !rc_test) 716 rc_test = rc; 717 718 rc = efx_test_interrupts(efx, tests); 719 if (rc && !rc_test) 720 rc_test = rc; 721 722 rc = efx_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 efx_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 netif_device_detach(efx->net_dev); 739 740 mutex_lock(&efx->mac_lock); 741 if (efx->loopback_modes) { 742 /* We need the 312 clock from the PHY to test the XMAC 743 * registers, so move into XGMII loopback if available */ 744 if (efx->loopback_modes & (1 << LOOPBACK_XGMII)) 745 efx->loopback_mode = LOOPBACK_XGMII; 746 else 747 efx->loopback_mode = __ffs(efx->loopback_modes); 748 } 749 750 __efx_reconfigure_port(efx); 751 mutex_unlock(&efx->mac_lock); 752 753 /* free up all consumers of SRAM (including all the queues) */ 754 efx_reset_down(efx, reset_method); 755 756 rc = efx_test_chip(efx, tests); 757 if (rc && !rc_test) 758 rc_test = rc; 759 760 /* reset the chip to recover from the register test */ 761 rc_reset = efx->type->reset(efx, reset_method); 762 763 /* Ensure that the phy is powered and out of loopback 764 * for the bist and loopback tests */ 765 efx->phy_mode &= ~PHY_MODE_LOW_POWER; 766 efx->loopback_mode = LOOPBACK_NONE; 767 768 rc = efx_reset_up(efx, reset_method, rc_reset == 0); 769 if (rc && !rc_reset) 770 rc_reset = rc; 771 772 if (rc_reset) { 773 netif_err(efx, drv, efx->net_dev, 774 "Unable to recover from chip test\n"); 775 efx_schedule_reset(efx, RESET_TYPE_DISABLE); 776 return rc_reset; 777 } 778 779 rc = efx_test_phy(efx, tests, flags); 780 if (rc && !rc_test) 781 rc_test = rc; 782 783 rc = efx_test_loopbacks(efx, tests, efx->loopback_modes); 784 if (rc && !rc_test) 785 rc_test = rc; 786 787 /* restore the PHY to the previous state */ 788 mutex_lock(&efx->mac_lock); 789 efx->phy_mode = phy_mode; 790 efx->loopback_mode = loopback_mode; 791 __efx_reconfigure_port(efx); 792 mutex_unlock(&efx->mac_lock); 793 794 netif_device_attach(efx->net_dev); 795 796 return rc_test; 797 } 798 799 void efx_selftest_async_start(struct efx_nic *efx) 800 { 801 struct efx_channel *channel; 802 803 efx_for_each_channel(channel, efx) 804 efx_nic_event_test_start(channel); 805 schedule_delayed_work(&efx->selftest_work, IRQ_TIMEOUT); 806 } 807 808 void efx_selftest_async_cancel(struct efx_nic *efx) 809 { 810 cancel_delayed_work_sync(&efx->selftest_work); 811 } 812 813 void efx_selftest_async_work(struct work_struct *data) 814 { 815 struct efx_nic *efx = container_of(data, struct efx_nic, 816 selftest_work.work); 817 struct efx_channel *channel; 818 int cpu; 819 820 efx_for_each_channel(channel, efx) { 821 cpu = efx_nic_event_test_irq_cpu(channel); 822 if (cpu < 0) 823 netif_err(efx, ifup, efx->net_dev, 824 "channel %d failed to trigger an interrupt\n", 825 channel->channel); 826 else 827 netif_dbg(efx, ifup, efx->net_dev, 828 "channel %d triggered interrupt on CPU %d\n", 829 channel->channel, cpu); 830 } 831 } 832