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 ; |
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(timeout: 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(nr: channel->channel, addr: &dma_pend); |
190 | set_bit(nr: channel->channel, addr: &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(timeout: 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(nr: channel->channel, addr: &napi_ran); |
208 | clear_bit(nr: channel->channel, addr: &dma_pend); |
209 | clear_bit(nr: channel->channel, addr: &int_pend); |
210 | } else { |
211 | if (efx_nic_event_present(channel)) |
212 | clear_bit(nr: channel->channel, addr: &dma_pend); |
213 | if (efx_nic_event_test_irq_cpu(channel) >= 0) |
214 | clear_bit(nr: channel->channel, addr: &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, results: tests->phy_ext, flags); |
265 | mutex_unlock(lock: &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(p: &received.header, q: &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(p: &received.ip, q: &payload->ip, size: 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(p: &received.msg, q: &payload->msg, size: 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(v: &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(v: &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(dst: (u8 *)&payload->header.h_dest, src: net_dev->dev_addr); |
387 | ether_addr_copy(dst: (u8 *)&payload->header.h_source, src: 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(v: &state->rx_good, i: 0); |
411 | atomic_set(v: &state->rx_bad, i: 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(size: sizeof(state->payload), 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, len: 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(dev: efx->net_dev); |
449 | rc = efx_enqueue_skb(tx_queue, skb); |
450 | netif_tx_unlock_bh(dev: 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(v: &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(dev: 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(dev: efx->net_dev); |
496 | |
497 | /* Check TX completion and received packet counts */ |
498 | rx_good = atomic_read(v: &state->rx_good); |
499 | rx_bad = atomic_read(v: &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(n: state->packet_count, |
546 | size: 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(msecs: 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(objp: 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(lock: &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(lock: &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, index: 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(size: 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(lock: &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 | lb_tests: &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(objp: 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, type: 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(lock: &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, loopback_modes: 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(lock: &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(dwork: &efx->selftest_work, IRQ_TIMEOUT); |
784 | } |
785 | |
786 | void efx_selftest_async_cancel(struct efx_nic *efx) |
787 | { |
788 | cancel_delayed_work_sync(dwork: &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 | |