Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright(c) 2019-2021 Xilinx, Inc.
4 : : * Copyright(c) 2012-2019 Solarflare Communications Inc.
5 : : */
6 : :
7 : : #include "efx.h"
8 : : #include "efx_impl.h"
9 : :
10 : :
11 : : #if EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10()
12 : :
13 : : __checkReturn efx_rc_t
14 : 0 : ef10_mac_poll(
15 : : __in efx_nic_t *enp,
16 : : __out efx_link_mode_t *link_modep)
17 : : {
18 : : efx_port_t *epp = &(enp->en_port);
19 : : ef10_link_state_t els;
20 : : efx_rc_t rc;
21 : :
22 [ # # ]: 0 : if ((rc = ef10_phy_get_link(enp, &els)) != 0)
23 : 0 : goto fail1;
24 : :
25 : 0 : epp->ep_adv_cap_mask = els.epls.epls_adv_cap_mask;
26 : 0 : epp->ep_fcntl = els.epls.epls_fcntl;
27 : :
28 : 0 : *link_modep = els.epls.epls_link_mode;
29 : :
30 : 0 : return (0);
31 : :
32 : : fail1:
33 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
34 : :
35 : 0 : *link_modep = EFX_LINK_UNKNOWN;
36 : :
37 : 0 : return (rc);
38 : : }
39 : :
40 : : __checkReturn efx_rc_t
41 : 0 : ef10_mac_up(
42 : : __in efx_nic_t *enp,
43 : : __out boolean_t *mac_upp)
44 : : {
45 : : ef10_link_state_t els;
46 : : efx_rc_t rc;
47 : :
48 : : /*
49 : : * Because EF10 doesn't *require* polling, we can't rely on
50 : : * ef10_mac_poll() being executed to populate epp->ep_mac_up.
51 : : */
52 [ # # ]: 0 : if ((rc = ef10_phy_get_link(enp, &els)) != 0)
53 : 0 : goto fail1;
54 : :
55 : 0 : *mac_upp = els.els_mac_up;
56 : :
57 : 0 : return (0);
58 : :
59 : : fail1:
60 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
61 : :
62 : 0 : return (rc);
63 : : }
64 : :
65 : : /*
66 : : * EF10 adapters use MC_CMD_VADAPTOR_SET_MAC to set the
67 : : * MAC address; the address field in MC_CMD_SET_MAC has no
68 : : * effect.
69 : : * MC_CMD_VADAPTOR_SET_MAC requires mac-spoofing privilege and
70 : : * the port to have no filters or queues active.
71 : : */
72 : : static __checkReturn efx_rc_t
73 : 0 : efx_mcdi_vadapter_set_mac(
74 : : __in efx_nic_t *enp)
75 : : {
76 : : efx_port_t *epp = &(enp->en_port);
77 : : efx_mcdi_req_t req;
78 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VADAPTOR_SET_MAC_IN_LEN,
79 : : MC_CMD_VADAPTOR_SET_MAC_OUT_LEN);
80 : : efx_rc_t rc;
81 : :
82 : 0 : req.emr_cmd = MC_CMD_VADAPTOR_SET_MAC;
83 : 0 : req.emr_in_buf = payload;
84 : 0 : req.emr_in_length = MC_CMD_VADAPTOR_SET_MAC_IN_LEN;
85 : 0 : req.emr_out_buf = payload;
86 : 0 : req.emr_out_length = MC_CMD_VADAPTOR_SET_MAC_OUT_LEN;
87 : :
88 : 0 : MCDI_IN_SET_DWORD(req, VADAPTOR_SET_MAC_IN_UPSTREAM_PORT_ID,
89 : : enp->en_vport_id);
90 : 0 : EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, VADAPTOR_SET_MAC_IN_MACADDR),
91 : : epp->ep_mac_addr);
92 : :
93 : 0 : efx_mcdi_execute(enp, &req);
94 : :
95 [ # # ]: 0 : if (req.emr_rc != 0) {
96 : : rc = req.emr_rc;
97 : 0 : goto fail1;
98 : : }
99 : :
100 : : return (0);
101 : :
102 : : fail1:
103 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
104 : :
105 : 0 : return (rc);
106 : : }
107 : :
108 : : __checkReturn efx_rc_t
109 : 0 : ef10_mac_addr_set(
110 : : __in efx_nic_t *enp)
111 : : {
112 : : efx_rc_t rc;
113 : :
114 [ # # ]: 0 : if ((rc = efx_mcdi_vadapter_set_mac(enp)) != 0) {
115 [ # # ]: 0 : if (rc != ENOTSUP)
116 : 0 : goto fail1;
117 : :
118 : : /*
119 : : * Fallback for older Huntington firmware without Vadapter
120 : : * support.
121 : : */
122 [ # # ]: 0 : if ((rc = ef10_mac_reconfigure(enp)) != 0)
123 : 0 : goto fail2;
124 : : }
125 : :
126 : : return (0);
127 : :
128 : : fail2:
129 : : EFSYS_PROBE(fail2);
130 : :
131 : : fail1:
132 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
133 : :
134 : : return (rc);
135 : : }
136 : :
137 : : static __checkReturn efx_rc_t
138 : 0 : efx_mcdi_mtu_set(
139 : : __in efx_nic_t *enp,
140 : : __in uint32_t mtu)
141 : : {
142 : : efx_mcdi_req_t req;
143 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_MAC_EXT_IN_LEN,
144 : : MC_CMD_SET_MAC_OUT_LEN);
145 : : efx_rc_t rc;
146 : :
147 : 0 : req.emr_cmd = MC_CMD_SET_MAC;
148 : 0 : req.emr_in_buf = payload;
149 : 0 : req.emr_in_length = MC_CMD_SET_MAC_EXT_IN_LEN;
150 : 0 : req.emr_out_buf = payload;
151 : 0 : req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN;
152 : :
153 : : /* Only configure the MTU in this call to MC_CMD_SET_MAC */
154 : 0 : MCDI_IN_SET_DWORD(req, SET_MAC_EXT_IN_MTU, mtu);
155 : 0 : MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_EXT_IN_CONTROL,
156 : : SET_MAC_EXT_IN_CFG_MTU, 1);
157 : :
158 : 0 : efx_mcdi_execute(enp, &req);
159 : :
160 [ # # ]: 0 : if (req.emr_rc != 0) {
161 : : rc = req.emr_rc;
162 : 0 : goto fail1;
163 : : }
164 : :
165 : : return (0);
166 : :
167 : : fail1:
168 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
169 : :
170 : 0 : return (rc);
171 : : }
172 : :
173 : : static __checkReturn efx_rc_t
174 : 0 : efx_mcdi_mtu_get(
175 : : __in efx_nic_t *enp,
176 : : __out size_t *mtu)
177 : : {
178 : : efx_mcdi_req_t req;
179 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_MAC_EXT_IN_LEN,
180 : : MC_CMD_SET_MAC_V2_OUT_LEN);
181 : : efx_rc_t rc;
182 : :
183 : 0 : req.emr_cmd = MC_CMD_SET_MAC;
184 : 0 : req.emr_in_buf = payload;
185 : 0 : req.emr_in_length = MC_CMD_SET_MAC_EXT_IN_LEN;
186 : 0 : req.emr_out_buf = payload;
187 : 0 : req.emr_out_length = MC_CMD_SET_MAC_V2_OUT_LEN;
188 : :
189 : : /*
190 : : * With MC_CMD_SET_MAC_EXT_IN_CONTROL set to 0, this just queries the
191 : : * MTU. This should always be supported on Medford, but it is not
192 : : * supported on older Huntington firmware.
193 : : */
194 : : MCDI_IN_SET_DWORD(req, SET_MAC_EXT_IN_CONTROL, 0);
195 : :
196 : 0 : efx_mcdi_execute(enp, &req);
197 : :
198 [ # # ]: 0 : if (req.emr_rc != 0) {
199 : : rc = req.emr_rc;
200 : 0 : goto fail1;
201 : : }
202 [ # # ]: 0 : if (req.emr_out_length_used < MC_CMD_SET_MAC_V2_OUT_MTU_OFST + 4) {
203 : : rc = EMSGSIZE;
204 : 0 : goto fail2;
205 : : }
206 : :
207 : 0 : *mtu = MCDI_OUT_DWORD(req, SET_MAC_V2_OUT_MTU);
208 : :
209 : 0 : return (0);
210 : :
211 : : fail2:
212 : : EFSYS_PROBE(fail2);
213 : : fail1:
214 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
215 : :
216 : : return (rc);
217 : : }
218 : :
219 : : __checkReturn efx_rc_t
220 : 0 : ef10_mac_pdu_set(
221 : : __in efx_nic_t *enp)
222 : : {
223 : : efx_port_t *epp = &(enp->en_port);
224 : : efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
225 : : efx_rc_t rc;
226 : :
227 [ # # ]: 0 : if (encp->enc_enhanced_set_mac_supported) {
228 [ # # ]: 0 : if ((rc = efx_mcdi_mtu_set(enp, epp->ep_mac_pdu)) != 0)
229 : 0 : goto fail1;
230 : : } else {
231 : : /*
232 : : * Fallback for older Huntington firmware, which always
233 : : * configure all of the parameters to MC_CMD_SET_MAC. This isn't
234 : : * suitable for setting the MTU on unpriviliged functions.
235 : : */
236 [ # # ]: 0 : if ((rc = ef10_mac_reconfigure(enp)) != 0)
237 : 0 : goto fail2;
238 : : }
239 : :
240 : : return (0);
241 : :
242 : : fail2:
243 : : EFSYS_PROBE(fail2);
244 : : fail1:
245 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
246 : :
247 : : return (rc);
248 : : }
249 : :
250 : : __checkReturn efx_rc_t
251 : 0 : ef10_mac_pdu_get(
252 : : __in efx_nic_t *enp,
253 : : __out size_t *pdu)
254 : : {
255 : : efx_rc_t rc;
256 : :
257 [ # # ]: 0 : if ((rc = efx_mcdi_mtu_get(enp, pdu)) != 0)
258 : 0 : goto fail1;
259 : :
260 : : return (0);
261 : :
262 : : fail1:
263 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
264 : :
265 : 0 : return (rc);
266 : : }
267 : :
268 : : __checkReturn efx_rc_t
269 : 0 : ef10_mac_reconfigure(
270 : : __in efx_nic_t *enp)
271 : : {
272 : : efx_port_t *epp = &(enp->en_port);
273 : : efx_mcdi_req_t req;
274 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_MAC_IN_LEN,
275 : : MC_CMD_SET_MAC_OUT_LEN);
276 : : efx_rc_t rc;
277 : :
278 : 0 : req.emr_cmd = MC_CMD_SET_MAC;
279 : 0 : req.emr_in_buf = payload;
280 : 0 : req.emr_in_length = MC_CMD_SET_MAC_IN_LEN;
281 : 0 : req.emr_out_buf = payload;
282 : 0 : req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN;
283 : :
284 : 0 : MCDI_IN_SET_DWORD(req, SET_MAC_IN_MTU, epp->ep_mac_pdu);
285 [ # # ]: 0 : MCDI_IN_SET_DWORD(req, SET_MAC_IN_DRAIN, epp->ep_mac_drain ? 1 : 0);
286 : 0 : EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, SET_MAC_IN_ADDR),
287 : : epp->ep_mac_addr);
288 : :
289 : : /*
290 : : * Note: The Huntington MAC does not support REJECT_BRDCST.
291 : : * The REJECT_UNCST flag will also prevent multicast traffic
292 : : * from reaching the filters. As Huntington filters drop any
293 : : * traffic that does not match a filter it is ok to leave the
294 : : * MAC running in promiscuous mode. See bug41141.
295 : : *
296 : : * FIXME: Does REJECT_UNCST behave the same way on Medford?
297 : : */
298 : : MCDI_IN_POPULATE_DWORD_2(req, SET_MAC_IN_REJECT,
299 : : SET_MAC_IN_REJECT_UNCST, 0,
300 : : SET_MAC_IN_REJECT_BRDCST, 0);
301 : :
302 : : /*
303 : : * Flow control, whether it is auto-negotiated or not,
304 : : * is set via the PHY advertised capabilities. When set to
305 : : * automatic the MAC will use the PHY settings to determine
306 : : * the flow control settings.
307 : : */
308 : 0 : MCDI_IN_SET_DWORD(req, SET_MAC_IN_FCNTL, MC_CMD_FCNTL_AUTO);
309 : :
310 : : /* Include the Ethernet frame checksum in RX packets if it's required */
311 [ # # ]: 0 : MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_IN_FLAGS,
312 : : SET_MAC_IN_FLAG_INCLUDE_FCS,
313 : : epp->ep_include_fcs ? 1 : 0);
314 : :
315 : 0 : efx_mcdi_execute_quiet(enp, &req);
316 : :
317 [ # # ]: 0 : if (req.emr_rc != 0) {
318 : : /*
319 : : * Unprivileged functions cannot control link state,
320 : : * but still need to configure filters.
321 : : */
322 [ # # ]: 0 : if (req.emr_rc != EACCES) {
323 : : rc = req.emr_rc;
324 : 0 : goto fail1;
325 : : }
326 : : }
327 : :
328 : : /*
329 : : * Apply the filters for the MAC configuration.
330 : : * If the NIC isn't ready to accept filters this may
331 : : * return success without setting anything.
332 : : */
333 : 0 : rc = efx_filter_reconfigure(enp, epp->ep_mac_addr,
334 : 0 : epp->ep_all_unicst, epp->ep_mulcst,
335 : 0 : epp->ep_all_mulcst, epp->ep_brdcst,
336 : 0 : epp->ep_mulcst_addr_list,
337 : : epp->ep_mulcst_addr_count);
338 : :
339 : 0 : return (0);
340 : :
341 : : fail1:
342 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
343 : :
344 : 0 : return (rc);
345 : : }
346 : :
347 : : __checkReturn efx_rc_t
348 : 0 : ef10_mac_multicast_list_set(
349 : : __in efx_nic_t *enp)
350 : : {
351 : : efx_port_t *epp = &(enp->en_port);
352 : 0 : const efx_mac_ops_t *emop = epp->ep_emop;
353 : : efx_rc_t rc;
354 : :
355 [ # # ]: 0 : EFSYS_ASSERT(EFX_FAMILY_IS_EF100(enp) || EFX_FAMILY_IS_EF10(enp));
356 : :
357 [ # # ]: 0 : if ((rc = emop->emo_reconfigure(enp)) != 0)
358 : 0 : goto fail1;
359 : :
360 : : return (0);
361 : :
362 : : fail1:
363 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
364 : :
365 : 0 : return (rc);
366 : : }
367 : :
368 : : __checkReturn efx_rc_t
369 : 0 : ef10_mac_filter_default_rxq_set(
370 : : __in efx_nic_t *enp,
371 : : __in efx_rxq_t *erp,
372 : : __in boolean_t using_rss)
373 : : {
374 : : efx_port_t *epp = &(enp->en_port);
375 : : efx_rxq_t *old_rxq;
376 : : boolean_t old_using_rss;
377 : : efx_rc_t rc;
378 : :
379 : 0 : ef10_filter_get_default_rxq(enp, &old_rxq, &old_using_rss);
380 : :
381 : 0 : ef10_filter_default_rxq_set(enp, erp, using_rss);
382 : :
383 : 0 : rc = efx_filter_reconfigure(enp, epp->ep_mac_addr,
384 : 0 : epp->ep_all_unicst, epp->ep_mulcst,
385 : 0 : epp->ep_all_mulcst, epp->ep_brdcst,
386 : 0 : epp->ep_mulcst_addr_list,
387 : : epp->ep_mulcst_addr_count);
388 : :
389 [ # # ]: 0 : if (rc != 0)
390 : 0 : goto fail1;
391 : :
392 : : return (0);
393 : :
394 : : fail1:
395 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
396 : :
397 : 0 : ef10_filter_default_rxq_set(enp, old_rxq, old_using_rss);
398 : :
399 : 0 : return (rc);
400 : : }
401 : :
402 : : void
403 : 0 : ef10_mac_filter_default_rxq_clear(
404 : : __in efx_nic_t *enp)
405 : : {
406 : : efx_port_t *epp = &(enp->en_port);
407 : :
408 : 0 : ef10_filter_default_rxq_clear(enp);
409 : :
410 : 0 : (void) efx_filter_reconfigure(enp, epp->ep_mac_addr,
411 : 0 : epp->ep_all_unicst, epp->ep_mulcst,
412 : 0 : epp->ep_all_mulcst, epp->ep_brdcst,
413 : 0 : epp->ep_mulcst_addr_list,
414 : : epp->ep_mulcst_addr_count);
415 : 0 : }
416 : :
417 : :
418 : : #if EFSYS_OPT_LOOPBACK
419 : :
420 : : __checkReturn efx_rc_t
421 : 0 : ef10_mac_loopback_set(
422 : : __in efx_nic_t *enp,
423 : : __in efx_link_mode_t link_mode,
424 : : __in efx_loopback_type_t loopback_type)
425 : : {
426 : : efx_port_t *epp = &(enp->en_port);
427 : 0 : const efx_phy_ops_t *epop = epp->ep_epop;
428 : : efx_loopback_type_t old_loopback_type;
429 : : efx_link_mode_t old_loopback_link_mode;
430 : : efx_rc_t rc;
431 : :
432 : : /* The PHY object handles this on EF10 */
433 : 0 : old_loopback_type = epp->ep_loopback_type;
434 : 0 : old_loopback_link_mode = epp->ep_loopback_link_mode;
435 : 0 : epp->ep_loopback_type = loopback_type;
436 : 0 : epp->ep_loopback_link_mode = link_mode;
437 : :
438 [ # # ]: 0 : if ((rc = epop->epo_reconfigure(enp)) != 0)
439 : 0 : goto fail1;
440 : :
441 : : return (0);
442 : :
443 : : fail1:
444 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
445 : :
446 : 0 : epp->ep_loopback_type = old_loopback_type;
447 : 0 : epp->ep_loopback_link_mode = old_loopback_link_mode;
448 : :
449 : 0 : return (rc);
450 : : }
451 : :
452 : : #endif /* EFSYS_OPT_LOOPBACK */
453 : :
454 : : #if EFSYS_OPT_MAC_STATS
455 : :
456 : : __checkReturn efx_rc_t
457 : 0 : ef10_mac_stats_get_mask(
458 : : __in efx_nic_t *enp,
459 : : __inout_bcount(mask_size) uint32_t *maskp,
460 : : __in size_t mask_size)
461 : : {
462 : 0 : const struct efx_mac_stats_range ef10_common[] = {
463 : : { EFX_MAC_RX_OCTETS, EFX_MAC_RX_GE_15XX_PKTS },
464 : : { EFX_MAC_RX_FCS_ERRORS, EFX_MAC_RX_DROP_EVENTS },
465 : : { EFX_MAC_RX_JABBER_PKTS, EFX_MAC_RX_JABBER_PKTS },
466 : : { EFX_MAC_RX_NODESC_DROP_CNT, EFX_MAC_TX_PAUSE_PKTS },
467 : : };
468 : 0 : const struct efx_mac_stats_range ef10_tx_size_bins[] = {
469 : : { EFX_MAC_TX_LE_64_PKTS, EFX_MAC_TX_GE_15XX_PKTS },
470 : : };
471 : : efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
472 : : efx_port_t *epp = &(enp->en_port);
473 : : efx_rc_t rc;
474 : :
475 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
476 : : ef10_common, EFX_ARRAY_SIZE(ef10_common))) != 0)
477 : 0 : goto fail1;
478 : :
479 [ # # ]: 0 : if (epp->ep_phy_cap_mask & (1 << MC_CMD_PHY_CAP_40000FDX_LBN)) {
480 : 0 : const struct efx_mac_stats_range ef10_40g_extra[] = {
481 : : { EFX_MAC_RX_ALIGN_ERRORS, EFX_MAC_RX_ALIGN_ERRORS },
482 : : };
483 : :
484 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
485 : : ef10_40g_extra, EFX_ARRAY_SIZE(ef10_40g_extra))) != 0)
486 : 0 : goto fail2;
487 : :
488 [ # # ]: 0 : if (encp->enc_mac_stats_40g_tx_size_bins) {
489 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp,
490 : : mask_size, ef10_tx_size_bins,
491 : : EFX_ARRAY_SIZE(ef10_tx_size_bins))) != 0)
492 : 0 : goto fail3;
493 : : }
494 : : } else {
495 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
496 : : ef10_tx_size_bins, EFX_ARRAY_SIZE(ef10_tx_size_bins))) != 0)
497 : 0 : goto fail4;
498 : : }
499 : :
500 [ # # ]: 0 : if (encp->enc_pm_and_rxdp_counters) {
501 : 0 : const struct efx_mac_stats_range ef10_pm_and_rxdp[] = {
502 : : { EFX_MAC_PM_TRUNC_BB_OVERFLOW, EFX_MAC_RXDP_HLB_WAIT },
503 : : };
504 : :
505 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
506 : : ef10_pm_and_rxdp, EFX_ARRAY_SIZE(ef10_pm_and_rxdp))) != 0)
507 : 0 : goto fail5;
508 : : }
509 : :
510 [ # # ]: 0 : if (encp->enc_datapath_cap_evb) {
511 : 0 : const struct efx_mac_stats_range ef10_vadaptor[] = {
512 : : { EFX_MAC_VADAPTER_RX_UNICAST_PACKETS,
513 : : EFX_MAC_VADAPTER_TX_OVERFLOW },
514 : : };
515 : :
516 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
517 : : ef10_vadaptor, EFX_ARRAY_SIZE(ef10_vadaptor))) != 0)
518 : 0 : goto fail6;
519 : : }
520 : :
521 [ # # ]: 0 : if (encp->enc_fec_counters) {
522 : 0 : const struct efx_mac_stats_range ef10_fec[] = {
523 : : { EFX_MAC_FEC_UNCORRECTED_ERRORS,
524 : : EFX_MAC_FEC_CORRECTED_SYMBOLS_LANE3 },
525 : : };
526 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
527 : : ef10_fec, EFX_ARRAY_SIZE(ef10_fec))) != 0)
528 : 0 : goto fail7;
529 : : }
530 : :
531 [ # # ]: 0 : if (encp->enc_mac_stats_nstats >= MC_CMD_MAC_NSTATS_V4) {
532 : 0 : const struct efx_mac_stats_range ef10_rxdp_sdt[] = {
533 : : { EFX_MAC_RXDP_SCATTER_DISABLED_TRUNC,
534 : : EFX_MAC_RXDP_SCATTER_DISABLED_TRUNC },
535 : : };
536 : :
537 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
538 : : ef10_rxdp_sdt, EFX_ARRAY_SIZE(ef10_rxdp_sdt))) != 0)
539 : 0 : goto fail8;
540 : : }
541 : :
542 [ # # ]: 0 : if (encp->enc_hlb_counters) {
543 : 0 : const struct efx_mac_stats_range ef10_hlb[] = {
544 : : { EFX_MAC_RXDP_HLB_IDLE, EFX_MAC_RXDP_HLB_TIMEOUT },
545 : : };
546 [ # # ]: 0 : if ((rc = efx_mac_stats_mask_add_ranges(maskp, mask_size,
547 : : ef10_hlb, EFX_ARRAY_SIZE(ef10_hlb))) != 0)
548 : 0 : goto fail9;
549 : : }
550 : :
551 : : return (0);
552 : :
553 : : fail9:
554 : : EFSYS_PROBE(fail9);
555 : : fail8:
556 : : EFSYS_PROBE(fail8);
557 : : fail7:
558 : : EFSYS_PROBE(fail7);
559 : : fail6:
560 : : EFSYS_PROBE(fail6);
561 : : fail5:
562 : : EFSYS_PROBE(fail5);
563 : : fail4:
564 : : EFSYS_PROBE(fail4);
565 : : fail3:
566 : : EFSYS_PROBE(fail3);
567 : : fail2:
568 : : EFSYS_PROBE(fail2);
569 : : fail1:
570 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
571 : :
572 : : return (rc);
573 : : }
574 : :
575 : : #define EF10_MAC_STAT_READ(_esmp, _field, _eqp) \
576 : : EFSYS_MEM_READQ((_esmp), (_field) * sizeof (efx_qword_t), _eqp)
577 : :
578 : :
579 : : __checkReturn efx_rc_t
580 : 0 : ef10_mac_stats_update(
581 : : __in efx_nic_t *enp,
582 : : __in efsys_mem_t *esmp,
583 : : __inout_ecount(EFX_MAC_NSTATS) efsys_stat_t *stat,
584 : : __inout_opt uint32_t *generationp)
585 : : {
586 : : const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
587 : : efx_qword_t generation_start;
588 : : efx_qword_t generation_end;
589 : : efx_qword_t value;
590 : : efx_rc_t rc;
591 : :
592 : : /*
593 : : * The MAC_STATS contain start and end generation counters used to
594 : : * detect when the DMA buffer has been updated during stats decode.
595 : : * All stats counters are 64bit unsigned values.
596 : : *
597 : : * Siena-compatible MAC stats contain MC_CMD_MAC_NSTATS 64bit counters.
598 : : * The generation end counter is at index MC_CMD_MAC_GENERATION_END
599 : : * (same as MC_CMD_MAC_NSTATS-1).
600 : : *
601 : : * Medford2 and later use a larger DMA buffer: MAC_STATS_NUM_STATS from
602 : : * MC_CMD_GET_CAPABILITIES_V4_OUT reports the number of 64bit counters.
603 : : *
604 : : * Firmware writes the generation end counter as the last counter in the
605 : : * DMA buffer. Do not use MC_CMD_MAC_GENERATION_END, as that is only
606 : : * correct for legacy Siena-compatible MAC stats.
607 : : */
608 : :
609 [ # # ]: 0 : if (encp->enc_mac_stats_nstats < MC_CMD_MAC_NSTATS) {
610 : : /* MAC stats count too small for legacy MAC stats */
611 : : rc = ENOSPC;
612 : 0 : goto fail1;
613 : : }
614 : 0 : if (EFSYS_MEM_SIZE(esmp) <
615 [ # # ]: 0 : (encp->enc_mac_stats_nstats * sizeof (efx_qword_t))) {
616 : : /* DMA buffer too small */
617 : : rc = ENOSPC;
618 : 0 : goto fail2;
619 : : }
620 : :
621 : : /* Read END first so we don't race with the MC */
622 : : EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFSYS_MEM_SIZE(esmp));
623 : 0 : EF10_MAC_STAT_READ(esmp, (encp->enc_mac_stats_nstats - 1),
624 : : &generation_end);
625 : : EFSYS_MEM_READ_BARRIER();
626 : :
627 : : /* TX */
628 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PKTS, &value);
629 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value);
630 : :
631 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_CONTROL_PKTS, &value);
632 : 0 : EFSYS_STAT_SUBR_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value);
633 : :
634 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PAUSE_PKTS, &value);
635 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PAUSE_PKTS]), &value);
636 : :
637 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_UNICAST_PKTS, &value);
638 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_UNICST_PKTS]), &value);
639 : :
640 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTICAST_PKTS, &value);
641 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULTICST_PKTS]), &value);
642 : :
643 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BROADCAST_PKTS, &value);
644 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_BRDCST_PKTS]), &value);
645 : :
646 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BYTES, &value);
647 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_OCTETS]), &value);
648 : :
649 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LT64_PKTS, &value);
650 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value);
651 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_64_PKTS, &value);
652 : 0 : EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value);
653 : :
654 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_65_TO_127_PKTS, &value);
655 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_65_TO_127_PKTS]), &value);
656 : :
657 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_128_TO_255_PKTS, &value);
658 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_128_TO_255_PKTS]), &value);
659 : :
660 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_256_TO_511_PKTS, &value);
661 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_256_TO_511_PKTS]), &value);
662 : :
663 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_512_TO_1023_PKTS, &value);
664 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_512_TO_1023_PKTS]), &value);
665 : :
666 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_1024_TO_15XX_PKTS, &value);
667 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_1024_TO_15XX_PKTS]), &value);
668 : :
669 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_15XX_TO_JUMBO_PKTS, &value);
670 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value);
671 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_GTJUMBO_PKTS, &value);
672 : 0 : EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value);
673 : :
674 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BAD_FCS_PKTS, &value);
675 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_ERRORS]), &value);
676 : :
677 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_SINGLE_COLLISION_PKTS, &value);
678 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_SGL_COL_PKTS]), &value);
679 : :
680 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTIPLE_COLLISION_PKTS,
681 : : &value);
682 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULT_COL_PKTS]), &value);
683 : :
684 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_COLLISION_PKTS,
685 : : &value);
686 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_COL_PKTS]), &value);
687 : :
688 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LATE_COLLISION_PKTS, &value);
689 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LATE_COL_PKTS]), &value);
690 : :
691 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_DEFERRED_PKTS, &value);
692 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_DEF_PKTS]), &value);
693 : :
694 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_DEFERRED_PKTS,
695 : : &value);
696 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_DEF_PKTS]), &value);
697 : :
698 : : /* RX */
699 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BYTES, &value);
700 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_OCTETS]), &value);
701 : :
702 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PKTS, &value);
703 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PKTS]), &value);
704 : :
705 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNICAST_PKTS, &value);
706 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_UNICST_PKTS]), &value);
707 : :
708 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MULTICAST_PKTS, &value);
709 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MULTICST_PKTS]), &value);
710 : :
711 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BROADCAST_PKTS, &value);
712 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_BRDCST_PKTS]), &value);
713 : :
714 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PAUSE_PKTS, &value);
715 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PAUSE_PKTS]), &value);
716 : :
717 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNDERSIZE_PKTS, &value);
718 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value);
719 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_64_PKTS, &value);
720 : 0 : EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value);
721 : :
722 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_65_TO_127_PKTS, &value);
723 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_65_TO_127_PKTS]), &value);
724 : :
725 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_128_TO_255_PKTS, &value);
726 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_128_TO_255_PKTS]), &value);
727 : :
728 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_256_TO_511_PKTS, &value);
729 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_256_TO_511_PKTS]), &value);
730 : :
731 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_512_TO_1023_PKTS, &value);
732 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_512_TO_1023_PKTS]), &value);
733 : :
734 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_1024_TO_15XX_PKTS, &value);
735 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_1024_TO_15XX_PKTS]), &value);
736 : :
737 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_15XX_TO_JUMBO_PKTS, &value);
738 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value);
739 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_GTJUMBO_PKTS, &value);
740 : 0 : EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value);
741 : :
742 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BAD_FCS_PKTS, &value);
743 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FCS_ERRORS]), &value);
744 : :
745 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_OVERFLOW_PKTS, &value);
746 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_DROP_EVENTS]), &value);
747 : :
748 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_FALSE_CARRIER_PKTS, &value);
749 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FALSE_CARRIER_ERRORS]), &value);
750 : :
751 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_SYMBOL_ERROR_PKTS, &value);
752 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_SYMBOL_ERRORS]), &value);
753 : :
754 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_ALIGN_ERROR_PKTS, &value);
755 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_ALIGN_ERRORS]), &value);
756 : :
757 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_INTERNAL_ERROR_PKTS, &value);
758 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_INTERNAL_ERRORS]), &value);
759 : :
760 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_JABBER_PKTS, &value);
761 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_JABBER_PKTS]), &value);
762 : :
763 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_CHAR_ERR, &value);
764 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_CHAR_ERR]),
765 : : &(value.eq_dword[0]));
766 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_CHAR_ERR]),
767 : : &(value.eq_dword[1]));
768 : :
769 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_CHAR_ERR, &value);
770 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_CHAR_ERR]),
771 : : &(value.eq_dword[0]));
772 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_CHAR_ERR]),
773 : : &(value.eq_dword[1]));
774 : :
775 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_DISP_ERR, &value);
776 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_DISP_ERR]),
777 : : &(value.eq_dword[0]));
778 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_DISP_ERR]),
779 : : &(value.eq_dword[1]));
780 : :
781 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_DISP_ERR, &value);
782 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_DISP_ERR]),
783 : : &(value.eq_dword[0]));
784 : 0 : EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_DISP_ERR]),
785 : : &(value.eq_dword[1]));
786 : :
787 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MATCH_FAULT, &value);
788 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MATCH_FAULT]), &value);
789 : :
790 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_NODESC_DROPS, &value);
791 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_NODESC_DROP_CNT]), &value);
792 : :
793 : : /* Packet memory (EF10 only) */
794 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_BB_OVERFLOW, &value);
795 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_BB_OVERFLOW]), &value);
796 : :
797 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_BB_OVERFLOW, &value);
798 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_BB_OVERFLOW]), &value);
799 : :
800 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_VFIFO_FULL, &value);
801 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_VFIFO_FULL]), &value);
802 : :
803 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_VFIFO_FULL, &value);
804 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_VFIFO_FULL]), &value);
805 : :
806 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_QBB, &value);
807 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_QBB]), &value);
808 : :
809 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_QBB, &value);
810 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_QBB]), &value);
811 : :
812 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_MAPPING, &value);
813 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_MAPPING]), &value);
814 : :
815 : : /* RX datapath */
816 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_Q_DISABLED_PKTS, &value);
817 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_Q_DISABLED_PKTS]), &value);
818 : :
819 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_DI_DROPPED_PKTS, &value);
820 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_DI_DROPPED_PKTS]), &value);
821 : :
822 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_STREAMING_PKTS, &value);
823 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_STREAMING_PKTS]), &value);
824 : :
825 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_FETCH_CONDITIONS, &value);
826 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_FETCH]), &value);
827 : :
828 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_WAIT_CONDITIONS, &value);
829 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_WAIT]), &value);
830 : :
831 : :
832 : : /* VADAPTER RX */
833 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_PACKETS,
834 : : &value);
835 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_PACKETS]),
836 : : &value);
837 : :
838 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_BYTES,
839 : : &value);
840 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_BYTES]),
841 : : &value);
842 : :
843 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_PACKETS,
844 : : &value);
845 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_PACKETS]),
846 : : &value);
847 : :
848 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_BYTES,
849 : : &value);
850 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_BYTES]),
851 : : &value);
852 : :
853 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_PACKETS,
854 : : &value);
855 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_PACKETS]),
856 : : &value);
857 : :
858 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_BYTES,
859 : : &value);
860 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_BYTES]),
861 : : &value);
862 : :
863 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_PACKETS,
864 : : &value);
865 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_PACKETS]),
866 : : &value);
867 : :
868 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_BYTES, &value);
869 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_BYTES]), &value);
870 : :
871 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_OVERFLOW, &value);
872 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_OVERFLOW]), &value);
873 : :
874 : : /* VADAPTER TX */
875 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_PACKETS,
876 : : &value);
877 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_PACKETS]),
878 : : &value);
879 : :
880 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_BYTES,
881 : : &value);
882 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_BYTES]),
883 : : &value);
884 : :
885 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_PACKETS,
886 : : &value);
887 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_PACKETS]),
888 : : &value);
889 : :
890 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_BYTES,
891 : : &value);
892 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_BYTES]),
893 : : &value);
894 : :
895 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_PACKETS,
896 : : &value);
897 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_PACKETS]),
898 : : &value);
899 : :
900 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_BYTES,
901 : : &value);
902 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_BYTES]),
903 : : &value);
904 : :
905 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_PACKETS, &value);
906 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_PACKETS]), &value);
907 : :
908 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_BYTES, &value);
909 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_BYTES]), &value);
910 : :
911 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_OVERFLOW, &value);
912 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_OVERFLOW]), &value);
913 : :
914 : :
915 [ # # ]: 0 : if (encp->enc_mac_stats_nstats < MC_CMD_MAC_NSTATS_V2)
916 : 0 : goto done;
917 : :
918 : : /* FEC */
919 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_UNCORRECTED_ERRORS, &value);
920 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_UNCORRECTED_ERRORS]), &value);
921 : :
922 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_CORRECTED_ERRORS, &value);
923 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_CORRECTED_ERRORS]), &value);
924 : :
925 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_CORRECTED_SYMBOLS_LANE0,
926 : : &value);
927 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_CORRECTED_SYMBOLS_LANE0]),
928 : : &value);
929 : :
930 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_CORRECTED_SYMBOLS_LANE1,
931 : : &value);
932 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_CORRECTED_SYMBOLS_LANE1]),
933 : : &value);
934 : :
935 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_CORRECTED_SYMBOLS_LANE2,
936 : : &value);
937 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_CORRECTED_SYMBOLS_LANE2]),
938 : : &value);
939 : :
940 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_FEC_CORRECTED_SYMBOLS_LANE3,
941 : : &value);
942 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_FEC_CORRECTED_SYMBOLS_LANE3]),
943 : : &value);
944 : :
945 [ # # ]: 0 : if (encp->enc_mac_stats_nstats < MC_CMD_MAC_NSTATS_V3)
946 : 0 : goto done;
947 : :
948 : : /* CTPIO exceptions */
949 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_VI_BUSY_FALLBACK, &value);
950 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_VI_BUSY_FALLBACK]), &value);
951 : :
952 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_LONG_WRITE_SUCCESS, &value);
953 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_LONG_WRITE_SUCCESS]), &value);
954 : :
955 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_MISSING_DBELL_FAIL, &value);
956 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_MISSING_DBELL_FAIL]), &value);
957 : :
958 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_OVERFLOW_FAIL, &value);
959 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_OVERFLOW_FAIL]), &value);
960 : :
961 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_UNDERFLOW_FAIL, &value);
962 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_UNDERFLOW_FAIL]), &value);
963 : :
964 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_TIMEOUT_FAIL, &value);
965 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_TIMEOUT_FAIL]), &value);
966 : :
967 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_NONCONTIG_WR_FAIL, &value);
968 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_NONCONTIG_WR_FAIL]), &value);
969 : :
970 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_FRM_CLOBBER_FAIL, &value);
971 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_FRM_CLOBBER_FAIL]), &value);
972 : :
973 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_INVALID_WR_FAIL, &value);
974 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_INVALID_WR_FAIL]), &value);
975 : :
976 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_VI_CLOBBER_FALLBACK, &value);
977 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_VI_CLOBBER_FALLBACK]),
978 : : &value);
979 : :
980 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_UNQUALIFIED_FALLBACK, &value);
981 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_UNQUALIFIED_FALLBACK]),
982 : : &value);
983 : :
984 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_RUNT_FALLBACK, &value);
985 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_RUNT_FALLBACK]), &value);
986 : :
987 : : /* CTPIO per-port stats */
988 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_SUCCESS, &value);
989 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_SUCCESS]), &value);
990 : :
991 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_FALLBACK, &value);
992 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_FALLBACK]), &value);
993 : :
994 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_POISON, &value);
995 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_POISON]), &value);
996 : :
997 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_CTPIO_ERASE, &value);
998 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_CTPIO_ERASE]), &value);
999 : :
1000 [ # # ]: 0 : if (encp->enc_mac_stats_nstats < MC_CMD_MAC_NSTATS_V4)
1001 : 0 : goto done;
1002 : :
1003 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_SCATTER_DISABLED_TRUNC,
1004 : : &value);
1005 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_SCATTER_DISABLED_TRUNC]),
1006 : : &value);
1007 : :
1008 : : /* Head-of-line blocking */
1009 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_IDLE, &value);
1010 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_IDLE]), &value);
1011 : :
1012 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_TIMEOUT, &value);
1013 : 0 : EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_TIMEOUT]), &value);
1014 : :
1015 : 0 : done:
1016 : : /* Read START generation counter */
1017 : : EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFSYS_MEM_SIZE(esmp));
1018 : : EFSYS_MEM_READ_BARRIER();
1019 : 0 : EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_GENERATION_START,
1020 : : &generation_start);
1021 : :
1022 : : /* Check that we didn't read the stats in the middle of a DMA */
1023 : : /* Not a good enough check ? */
1024 [ # # ]: 0 : if (memcmp(&generation_start, &generation_end,
1025 : : sizeof (generation_start)))
1026 : : return (EAGAIN);
1027 : :
1028 [ # # ]: 0 : if (generationp)
1029 : 0 : *generationp = EFX_QWORD_FIELD(generation_start, EFX_DWORD_0);
1030 : :
1031 : : return (0);
1032 : :
1033 : : fail2:
1034 : : EFSYS_PROBE(fail2);
1035 : 0 : fail1:
1036 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
1037 : :
1038 : : return (rc);
1039 : : }
1040 : :
1041 : : #endif /* EFSYS_OPT_MAC_STATS */
1042 : :
1043 : : #endif /* EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() */
|