820 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/****************************************************************************3 * Driver for Solarflare network controllers and boards4 * 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. a30 * slow serial console or an old IDE driver doing error recovery31 * - The PREEMPT_RT patches mostly deal with this, but also allow a32 * tasklet or normal task to be given higher priority than our IRQ33 * threads34 * Try to avoid blaming the hardware for this.35 */36#define IRQ_TIMEOUT HZ37 38/*39 * Loopback test packet structure40 *41 * The self-test should stress every RSS vector, and unfortunately42 * Falcon only performs RSS on TCP/UDP packets.43 */44struct efx_loopback_payload {45 char pad[2]; /* Ensures ip is 4-byte aligned */46 struct_group_attr(packet, __packed,47 struct ethhdr header;48 struct iphdr ip;49 struct udphdr udp;50 __be16 iteration;51 char msg[64];52 );53} __packed __aligned(4);54#define EFX_LOOPBACK_PAYLOAD_LEN \55 sizeof_field(struct efx_loopback_payload, packet)56 57/* Loopback test source MAC address */58static const u8 payload_source[ETH_ALEN] __aligned(2) = {59 0x00, 0x0f, 0x53, 0x1b, 0x1b, 0x1b,60};61 62static const char payload_msg[] =63 "Hello world! This is an Efx loopback test in progress!";64 65/* Interrupt mode names */66static const unsigned int efx_siena_interrupt_mode_max = EFX_INT_MODE_MAX;67static const char *const efx_siena_interrupt_mode_names[] = {68 [EFX_INT_MODE_MSIX] = "MSI-X",69 [EFX_INT_MODE_MSI] = "MSI",70 [EFX_INT_MODE_LEGACY] = "legacy",71};72#define INT_MODE(efx) \73 STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_siena_interrupt_mode)74 75/**76 * struct efx_loopback_state - persistent state during a loopback selftest77 * @flush: Drop all packets in efx_siena_loopback_rx_packet78 * @packet_count: Number of packets being used in this test79 * @skbs: An array of skbs transmitted80 * @offload_csum: Checksums are being offloaded81 * @rx_good: RX good packet count82 * @rx_bad: RX bad packet count83 * @payload: Payload used in tests84 */85struct efx_loopback_state {86 bool flush;87 int packet_count;88 struct sk_buff **skbs;89 bool offload_csum;90 atomic_t rx_good;91 atomic_t rx_bad;92 struct efx_loopback_payload payload;93};94 95/* How long to wait for all the packets to arrive (in ms) */96#define LOOPBACK_TIMEOUT_MS 100097 98/**************************************************************************99 *100 * MII, NVRAM and register tests101 *102 **************************************************************************/103 104static int efx_test_phy_alive(struct efx_nic *efx, struct efx_self_tests *tests)105{106 int rc = 0;107 108 rc = efx_siena_mcdi_phy_test_alive(efx);109 tests->phy_alive = rc ? -1 : 1;110 111 return rc;112}113 114static int efx_test_nvram(struct efx_nic *efx, struct efx_self_tests *tests)115{116 int rc = 0;117 118 if (efx->type->test_nvram) {119 rc = efx->type->test_nvram(efx);120 if (rc == -EPERM)121 rc = 0;122 else123 tests->nvram = rc ? -1 : 1;124 }125 126 return rc;127}128 129/**************************************************************************130 *131 * Interrupt and event queue testing132 *133 **************************************************************************/134 135/* Test generation and receipt of interrupts */136static int efx_test_interrupts(struct efx_nic *efx,137 struct efx_self_tests *tests)138{139 unsigned long timeout, wait;140 int cpu;141 int rc;142 143 netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n");144 tests->interrupt = -1;145 146 rc = efx_siena_irq_test_start(efx);147 if (rc == -ENOTSUPP) {148 netif_dbg(efx, drv, efx->net_dev,149 "direct interrupt testing not supported\n");150 tests->interrupt = 0;151 return 0;152 }153 154 timeout = jiffies + IRQ_TIMEOUT;155 wait = 1;156 157 /* Wait for arrival of test interrupt. */158 netif_dbg(efx, drv, efx->net_dev, "waiting for test interrupt\n");159 do {160 schedule_timeout_uninterruptible(wait);161 cpu = efx_nic_irq_test_irq_cpu(efx);162 if (cpu >= 0)163 goto success;164 wait *= 2;165 } while (time_before(jiffies, timeout));166 167 netif_err(efx, drv, efx->net_dev, "timed out waiting for interrupt\n");168 return -ETIMEDOUT;169 170 success:171 netif_dbg(efx, drv, efx->net_dev, "%s test interrupt seen on CPU%d\n",172 INT_MODE(efx), cpu);173 tests->interrupt = 1;174 return 0;175}176 177/* Test generation and receipt of interrupting events */178static int efx_test_eventq_irq(struct efx_nic *efx,179 struct efx_self_tests *tests)180{181 struct efx_channel *channel;182 unsigned int read_ptr[EFX_MAX_CHANNELS];183 unsigned long napi_ran = 0, dma_pend = 0, int_pend = 0;184 unsigned long timeout, wait;185 186 BUILD_BUG_ON(EFX_MAX_CHANNELS > BITS_PER_LONG);187 188 efx_for_each_channel(channel, efx) {189 read_ptr[channel->channel] = channel->eventq_read_ptr;190 set_bit(channel->channel, &dma_pend);191 set_bit(channel->channel, &int_pend);192 efx_siena_event_test_start(channel);193 }194 195 timeout = jiffies + IRQ_TIMEOUT;196 wait = 1;197 198 /* Wait for arrival of interrupts. NAPI processing may or may199 * not complete in time, but we can cope in any case.200 */201 do {202 schedule_timeout_uninterruptible(wait);203 204 efx_for_each_channel(channel, efx) {205 efx_siena_stop_eventq(channel);206 if (channel->eventq_read_ptr !=207 read_ptr[channel->channel]) {208 set_bit(channel->channel, &napi_ran);209 clear_bit(channel->channel, &dma_pend);210 clear_bit(channel->channel, &int_pend);211 } else {212 if (efx_siena_event_present(channel))213 clear_bit(channel->channel, &dma_pend);214 if (efx_nic_event_test_irq_cpu(channel) >= 0)215 clear_bit(channel->channel, &int_pend);216 }217 efx_siena_start_eventq(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 DMA238 * worked239 */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 259static int efx_test_phy(struct efx_nic *efx, struct efx_self_tests *tests,260 unsigned flags)261{262 int rc;263 264 mutex_lock(&efx->mac_lock);265 rc = efx_siena_mcdi_phy_run_tests(efx, tests->phy_ext, flags);266 mutex_unlock(&efx->mac_lock);267 if (rc == -EPERM)268 rc = 0;269 else270 netif_info(efx, drv, efx->net_dev,271 "%s phy selftest\n", rc ? "Failed" : "Passed");272 273 return rc;274}275 276/**************************************************************************277 *278 * Loopback testing279 * NB Only one loopback test can be executing concurrently.280 *281 **************************************************************************/282 283/* Loopback test RX callback284 * This is called for each received packet during loopback testing.285 */286void efx_siena_loopback_rx_packet(struct efx_nic *efx,287 const char *buf_ptr, int pkt_len)288{289 struct efx_loopback_state *state = efx->loopback_selftest;290 struct efx_loopback_payload received;291 struct efx_loopback_payload *payload;292 293 BUG_ON(!buf_ptr);294 295 /* If we are just flushing, then drop the packet */296 if ((state == NULL) || state->flush)297 return;298 299 payload = &state->payload;300 301 memcpy(&received.packet, buf_ptr,302 min_t(int, pkt_len, EFX_LOOPBACK_PAYLOAD_LEN));303 received.ip.saddr = payload->ip.saddr;304 if (state->offload_csum)305 received.ip.check = payload->ip.check;306 307 /* Check that header exists */308 if (pkt_len < sizeof(received.header)) {309 netif_err(efx, drv, efx->net_dev,310 "saw runt RX packet (length %d) in %s loopback "311 "test\n", pkt_len, LOOPBACK_MODE(efx));312 goto err;313 }314 315 /* Check that the ethernet header exists */316 if (memcmp(&received.header, &payload->header, ETH_HLEN) != 0) {317 netif_err(efx, drv, efx->net_dev,318 "saw non-loopback RX packet in %s loopback test\n",319 LOOPBACK_MODE(efx));320 goto err;321 }322 323 /* Check packet length */324 if (pkt_len != EFX_LOOPBACK_PAYLOAD_LEN) {325 netif_err(efx, drv, efx->net_dev,326 "saw incorrect RX packet length %d (wanted %d) in "327 "%s loopback test\n", pkt_len,328 (int)EFX_LOOPBACK_PAYLOAD_LEN, LOOPBACK_MODE(efx));329 goto err;330 }331 332 /* Check that IP header matches */333 if (memcmp(&received.ip, &payload->ip, sizeof(payload->ip)) != 0) {334 netif_err(efx, drv, efx->net_dev,335 "saw corrupted IP header in %s loopback test\n",336 LOOPBACK_MODE(efx));337 goto err;338 }339 340 /* Check that msg and padding matches */341 if (memcmp(&received.msg, &payload->msg, sizeof(received.msg)) != 0) {342 netif_err(efx, drv, efx->net_dev,343 "saw corrupted RX packet in %s loopback test\n",344 LOOPBACK_MODE(efx));345 goto err;346 }347 348 /* Check that iteration matches */349 if (received.iteration != payload->iteration) {350 netif_err(efx, drv, efx->net_dev,351 "saw RX packet from iteration %d (wanted %d) in "352 "%s loopback test\n", ntohs(received.iteration),353 ntohs(payload->iteration), LOOPBACK_MODE(efx));354 goto err;355 }356 357 /* Increase correct RX count */358 netif_vdbg(efx, drv, efx->net_dev,359 "got loopback RX in %s loopback test\n", LOOPBACK_MODE(efx));360 361 atomic_inc(&state->rx_good);362 return;363 364 err:365#ifdef DEBUG366 if (atomic_read(&state->rx_bad) == 0) {367 netif_err(efx, drv, efx->net_dev, "received packet:\n");368 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,369 buf_ptr, pkt_len, 0);370 netif_err(efx, drv, efx->net_dev, "expected packet:\n");371 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 0x10, 1,372 &state->payload.packet, EFX_LOOPBACK_PAYLOAD_LEN,373 0);374 }375#endif376 atomic_inc(&state->rx_bad);377}378 379/* Initialise an efx_siena_selftest_state for a new iteration */380static void efx_iterate_state(struct efx_nic *efx)381{382 struct efx_loopback_state *state = efx->loopback_selftest;383 struct net_device *net_dev = efx->net_dev;384 struct efx_loopback_payload *payload = &state->payload;385 386 /* Initialise the layerII header */387 ether_addr_copy((u8 *)&payload->header.h_dest, net_dev->dev_addr);388 ether_addr_copy((u8 *)&payload->header.h_source, payload_source);389 payload->header.h_proto = htons(ETH_P_IP);390 391 /* saddr set later and used as incrementing count */392 payload->ip.daddr = htonl(INADDR_LOOPBACK);393 payload->ip.ihl = 5;394 payload->ip.check = (__force __sum16) htons(0xdead);395 payload->ip.tot_len = htons(sizeof(*payload) -396 offsetof(struct efx_loopback_payload, ip));397 payload->ip.version = IPVERSION;398 payload->ip.protocol = IPPROTO_UDP;399 400 /* Initialise udp header */401 payload->udp.source = 0;402 payload->udp.len = htons(sizeof(*payload) -403 offsetof(struct efx_loopback_payload, udp));404 payload->udp.check = 0; /* checksum ignored */405 406 /* Fill out payload */407 payload->iteration = htons(ntohs(payload->iteration) + 1);408 memcpy(&payload->msg, payload_msg, sizeof(payload_msg));409 410 /* Fill out remaining state members */411 atomic_set(&state->rx_good, 0);412 atomic_set(&state->rx_bad, 0);413 smp_wmb();414}415 416static int efx_begin_loopback(struct efx_tx_queue *tx_queue)417{418 struct efx_nic *efx = tx_queue->efx;419 struct efx_loopback_state *state = efx->loopback_selftest;420 struct efx_loopback_payload *payload;421 struct sk_buff *skb;422 int i;423 netdev_tx_t rc;424 425 /* Transmit N copies of buffer */426 for (i = 0; i < state->packet_count; i++) {427 /* Allocate an skb, holding an extra reference for428 * transmit completion counting */429 skb = alloc_skb(sizeof(state->payload), GFP_KERNEL);430 if (!skb)431 return -ENOMEM;432 state->skbs[i] = skb;433 skb_get(skb);434 435 /* Copy the payload in, incrementing the source address to436 * exercise the rss vectors */437 payload = skb_put(skb, sizeof(state->payload));438 memcpy(payload, &state->payload, sizeof(state->payload));439 payload->ip.saddr = htonl(INADDR_LOOPBACK | (i << 2));440 /* Strip off the leading padding */441 skb_pull(skb, offsetof(struct efx_loopback_payload, header));442 /* Strip off the trailing padding */443 skb_trim(skb, EFX_LOOPBACK_PAYLOAD_LEN);444 445 /* Ensure everything we've written is visible to the446 * interrupt handler. */447 smp_wmb();448 449 netif_tx_lock_bh(efx->net_dev);450 rc = efx_enqueue_skb(tx_queue, skb);451 netif_tx_unlock_bh(efx->net_dev);452 453 if (rc != NETDEV_TX_OK) {454 netif_err(efx, drv, efx->net_dev,455 "TX queue %d could not transmit packet %d of "456 "%d in %s loopback test\n", tx_queue->label,457 i + 1, state->packet_count,458 LOOPBACK_MODE(efx));459 460 /* Defer cleaning up the other skbs for the caller */461 kfree_skb(skb);462 return -EPIPE;463 }464 }465 466 return 0;467}468 469static int efx_poll_loopback(struct efx_nic *efx)470{471 struct efx_loopback_state *state = efx->loopback_selftest;472 473 return atomic_read(&state->rx_good) == state->packet_count;474}475 476static int efx_end_loopback(struct efx_tx_queue *tx_queue,477 struct efx_loopback_self_tests *lb_tests)478{479 struct efx_nic *efx = tx_queue->efx;480 struct efx_loopback_state *state = efx->loopback_selftest;481 struct sk_buff *skb;482 int tx_done = 0, rx_good, rx_bad;483 int i, rc = 0;484 485 netif_tx_lock_bh(efx->net_dev);486 487 /* Count the number of tx completions, and decrement the refcnt. Any488 * skbs not already completed will be free'd when the queue is flushed */489 for (i = 0; i < state->packet_count; i++) {490 skb = state->skbs[i];491 if (skb && !skb_shared(skb))492 ++tx_done;493 dev_kfree_skb(skb);494 }495 496 netif_tx_unlock_bh(efx->net_dev);497 498 /* Check TX completion and received packet counts */499 rx_good = atomic_read(&state->rx_good);500 rx_bad = atomic_read(&state->rx_bad);501 if (tx_done != state->packet_count) {502 /* Don't free the skbs; they will be picked up on TX503 * overflow or channel teardown.504 */505 netif_err(efx, drv, efx->net_dev,506 "TX queue %d saw only %d out of an expected %d "507 "TX completion events in %s loopback test\n",508 tx_queue->label, tx_done, state->packet_count,509 LOOPBACK_MODE(efx));510 rc = -ETIMEDOUT;511 /* Allow to fall through so we see the RX errors as well */512 }513 514 /* We may always be up to a flush away from our desired packet total */515 if (rx_good != state->packet_count) {516 netif_dbg(efx, drv, efx->net_dev,517 "TX queue %d saw only %d out of an expected %d "518 "received packets in %s loopback test\n",519 tx_queue->label, rx_good, state->packet_count,520 LOOPBACK_MODE(efx));521 rc = -ETIMEDOUT;522 /* Fall through */523 }524 525 /* Update loopback test structure */526 lb_tests->tx_sent[tx_queue->label] += state->packet_count;527 lb_tests->tx_done[tx_queue->label] += tx_done;528 lb_tests->rx_good += rx_good;529 lb_tests->rx_bad += rx_bad;530 531 return rc;532}533 534static int535efx_test_loopback(struct efx_tx_queue *tx_queue,536 struct efx_loopback_self_tests *lb_tests)537{538 struct efx_nic *efx = tx_queue->efx;539 struct efx_loopback_state *state = efx->loopback_selftest;540 int i, begin_rc, end_rc;541 542 for (i = 0; i < 3; i++) {543 /* Determine how many packets to send */544 state->packet_count = efx->txq_entries / 3;545 state->packet_count = min(1 << (i << 2), state->packet_count);546 state->skbs = kcalloc(state->packet_count,547 sizeof(state->skbs[0]), GFP_KERNEL);548 if (!state->skbs)549 return -ENOMEM;550 state->flush = false;551 552 netif_dbg(efx, drv, efx->net_dev,553 "TX queue %d (hw %d) testing %s loopback with %d packets\n",554 tx_queue->label, tx_queue->queue, LOOPBACK_MODE(efx),555 state->packet_count);556 557 efx_iterate_state(efx);558 begin_rc = efx_begin_loopback(tx_queue);559 560 /* This will normally complete very quickly, but be561 * prepared to wait much longer. */562 msleep(1);563 if (!efx_poll_loopback(efx)) {564 msleep(LOOPBACK_TIMEOUT_MS);565 efx_poll_loopback(efx);566 }567 568 end_rc = efx_end_loopback(tx_queue, lb_tests);569 kfree(state->skbs);570 571 if (begin_rc || end_rc) {572 /* Wait a while to ensure there are no packets573 * floating around after a failure. */574 schedule_timeout_uninterruptible(HZ / 10);575 return begin_rc ? begin_rc : end_rc;576 }577 }578 579 netif_dbg(efx, drv, efx->net_dev,580 "TX queue %d passed %s loopback test with a burst length "581 "of %d packets\n", tx_queue->label, LOOPBACK_MODE(efx),582 state->packet_count);583 584 return 0;585}586 587/* Wait for link up. On Falcon, we would prefer to rely on efx_monitor, but588 * any contention on the mac lock (via e.g. efx_mac_mcast_work) causes it589 * to delay and retry. Therefore, it's safer to just poll directly. Wait590 * for link up and any faults to dissipate. */591static int efx_wait_for_link(struct efx_nic *efx)592{593 struct efx_link_state *link_state = &efx->link_state;594 int count, link_up_count = 0;595 bool link_up;596 597 for (count = 0; count < 40; count++) {598 schedule_timeout_uninterruptible(HZ / 10);599 600 if (efx->type->monitor != NULL) {601 mutex_lock(&efx->mac_lock);602 efx->type->monitor(efx);603 mutex_unlock(&efx->mac_lock);604 }605 606 mutex_lock(&efx->mac_lock);607 link_up = link_state->up;608 if (link_up)609 link_up = !efx->type->check_mac_fault(efx);610 mutex_unlock(&efx->mac_lock);611 612 if (link_up) {613 if (++link_up_count == 2)614 return 0;615 } else {616 link_up_count = 0;617 }618 }619 620 return -ETIMEDOUT;621}622 623static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests,624 unsigned int loopback_modes)625{626 enum efx_loopback_mode mode;627 struct efx_loopback_state *state;628 struct efx_channel *channel =629 efx_get_channel(efx, efx->tx_channel_offset);630 struct efx_tx_queue *tx_queue;631 int rc = 0;632 633 /* Set the port loopback_selftest member. From this point on634 * all received packets will be dropped. Mark the state as635 * "flushing" so all inflight packets are dropped */636 state = kzalloc(sizeof(*state), GFP_KERNEL);637 if (state == NULL)638 return -ENOMEM;639 BUG_ON(efx->loopback_selftest);640 state->flush = true;641 efx->loopback_selftest = state;642 643 /* Test all supported loopback modes */644 for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) {645 if (!(loopback_modes & (1 << mode)))646 continue;647 648 /* Move the port into the specified loopback mode. */649 state->flush = true;650 mutex_lock(&efx->mac_lock);651 efx->loopback_mode = mode;652 rc = __efx_siena_reconfigure_port(efx);653 mutex_unlock(&efx->mac_lock);654 if (rc) {655 netif_err(efx, drv, efx->net_dev,656 "unable to move into %s loopback\n",657 LOOPBACK_MODE(efx));658 goto out;659 }660 661 rc = efx_wait_for_link(efx);662 if (rc) {663 netif_err(efx, drv, efx->net_dev,664 "loopback %s never came up\n",665 LOOPBACK_MODE(efx));666 goto out;667 }668 669 /* Test all enabled types of TX queue */670 efx_for_each_channel_tx_queue(tx_queue, channel) {671 state->offload_csum = (tx_queue->type &672 EFX_TXQ_TYPE_OUTER_CSUM);673 rc = efx_test_loopback(tx_queue,674 &tests->loopback[mode]);675 if (rc)676 goto out;677 }678 }679 680 out:681 /* Remove the flush. The caller will remove the loopback setting */682 state->flush = true;683 efx->loopback_selftest = NULL;684 wmb();685 kfree(state);686 687 if (rc == -EPERM)688 rc = 0;689 690 return rc;691}692 693/**************************************************************************694 *695 * Entry point696 *697 *************************************************************************/698 699int efx_siena_selftest(struct efx_nic *efx, struct efx_self_tests *tests,700 unsigned int flags)701{702 enum efx_loopback_mode loopback_mode = efx->loopback_mode;703 int phy_mode = efx->phy_mode;704 int rc_test = 0, rc_reset, rc;705 706 efx_siena_selftest_async_cancel(efx);707 708 /* Online (i.e. non-disruptive) testing709 * This checks interrupt generation, event delivery and PHY presence. */710 711 rc = efx_test_phy_alive(efx, tests);712 if (rc && !rc_test)713 rc_test = rc;714 715 rc = efx_test_nvram(efx, tests);716 if (rc && !rc_test)717 rc_test = rc;718 719 rc = efx_test_interrupts(efx, tests);720 if (rc && !rc_test)721 rc_test = rc;722 723 rc = efx_test_eventq_irq(efx, tests);724 if (rc && !rc_test)725 rc_test = rc;726 727 if (rc_test)728 return rc_test;729 730 if (!(flags & ETH_TEST_FL_OFFLINE))731 return efx_test_phy(efx, tests, flags);732 733 /* Offline (i.e. disruptive) testing734 * This checks MAC and PHY loopback on the specified port. */735 736 /* Detach the device so the kernel doesn't transmit during the737 * loopback test and the watchdog timeout doesn't fire.738 */739 efx_device_detach_sync(efx);740 741 if (efx->type->test_chip) {742 rc_reset = efx->type->test_chip(efx, tests);743 if (rc_reset) {744 netif_err(efx, hw, efx->net_dev,745 "Unable to recover from chip test\n");746 efx_siena_schedule_reset(efx, RESET_TYPE_DISABLE);747 return rc_reset;748 }749 750 if ((tests->memory < 0 || tests->registers < 0) && !rc_test)751 rc_test = -EIO;752 }753 754 /* Ensure that the phy is powered and out of loopback755 * for the bist and loopback tests */756 mutex_lock(&efx->mac_lock);757 efx->phy_mode &= ~PHY_MODE_LOW_POWER;758 efx->loopback_mode = LOOPBACK_NONE;759 __efx_siena_reconfigure_port(efx);760 mutex_unlock(&efx->mac_lock);761 762 rc = efx_test_phy(efx, tests, flags);763 if (rc && !rc_test)764 rc_test = rc;765 766 rc = efx_test_loopbacks(efx, tests, efx->loopback_modes);767 if (rc && !rc_test)768 rc_test = rc;769 770 /* restore the PHY to the previous state */771 mutex_lock(&efx->mac_lock);772 efx->phy_mode = phy_mode;773 efx->loopback_mode = loopback_mode;774 __efx_siena_reconfigure_port(efx);775 mutex_unlock(&efx->mac_lock);776 777 efx_device_attach_if_not_resetting(efx);778 779 return rc_test;780}781 782void efx_siena_selftest_async_start(struct efx_nic *efx)783{784 struct efx_channel *channel;785 786 efx_for_each_channel(channel, efx)787 efx_siena_event_test_start(channel);788 schedule_delayed_work(&efx->selftest_work, IRQ_TIMEOUT);789}790 791void efx_siena_selftest_async_cancel(struct efx_nic *efx)792{793 cancel_delayed_work_sync(&efx->selftest_work);794}795 796static void efx_siena_selftest_async_work(struct work_struct *data)797{798 struct efx_nic *efx = container_of(data, struct efx_nic,799 selftest_work.work);800 struct efx_channel *channel;801 int cpu;802 803 efx_for_each_channel(channel, efx) {804 cpu = efx_nic_event_test_irq_cpu(channel);805 if (cpu < 0)806 netif_err(efx, ifup, efx->net_dev,807 "channel %d failed to trigger an interrupt\n",808 channel->channel);809 else810 netif_dbg(efx, ifup, efx->net_dev,811 "channel %d triggered interrupt on CPU %d\n",812 channel->channel, cpu);813 }814}815 816void efx_siena_selftest_async_init(struct efx_nic *efx)817{818 INIT_DELAYED_WORK(&efx->selftest_work, efx_siena_selftest_async_work);819}820