ef10_mac.c revision 294253 
1/*-
2 * Copyright (c) 2012-2015 Solarflare Communications Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 *    this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 *    this list of conditions and the following disclaimer in the documentation
12 *    and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * The views and conclusions contained in the software and documentation are
27 * those of the authors and should not be interpreted as representing official
28 * policies, either expressed or implied, of the FreeBSD Project.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: head/sys/dev/sfxge/common/hunt_mac.c 294253 2016-01-18 06:19:28Z arybchik $");
33
34#include "efx.h"
35#include "efx_impl.h"
36
37
38#if EFSYS_OPT_HUNTINGTON
39
40	__checkReturn	efx_rc_t
41ef10_mac_poll(
42	__in		efx_nic_t *enp,
43	__out		efx_link_mode_t *link_modep)
44{
45	efx_port_t *epp = &(enp->en_port);
46	ef10_link_state_t els;
47	efx_rc_t rc;
48
49	if ((rc = ef10_phy_get_link(enp, &els)) != 0)
50		goto fail1;
51
52	epp->ep_adv_cap_mask = els.els_adv_cap_mask;
53	epp->ep_fcntl = els.els_fcntl;
54
55	*link_modep = els.els_link_mode;
56
57	return (0);
58
59fail1:
60	EFSYS_PROBE1(fail1, efx_rc_t, rc);
61
62	*link_modep = EFX_LINK_UNKNOWN;
63
64	return (rc);
65}
66
67	__checkReturn	efx_rc_t
68ef10_mac_up(
69	__in		efx_nic_t *enp,
70	__out		boolean_t *mac_upp)
71{
72	ef10_link_state_t els;
73	efx_rc_t rc;
74
75	/*
76	 * Because EF10 doesn't *require* polling, we can't rely on
77	 * ef10_mac_poll() being executed to populate epp->ep_mac_up.
78	 */
79	if ((rc = ef10_phy_get_link(enp, &els)) != 0)
80		goto fail1;
81
82	*mac_upp = els.els_mac_up;
83
84	return (0);
85
86fail1:
87	EFSYS_PROBE1(fail1, efx_rc_t, rc);
88
89	return (rc);
90}
91
92/*
93 * EF10 adapters use MC_CMD_VADAPTOR_SET_MAC to set the
94 * MAC address; the address field in MC_CMD_SET_MAC has no
95 * effect.
96 * MC_CMD_VADAPTOR_SET_MAC requires mac-spoofing privilege and
97 * the port to have no filters or queues active.
98 */
99static	__checkReturn	efx_rc_t
100efx_mcdi_vadapter_set_mac(
101	__in		efx_nic_t *enp)
102{
103	efx_port_t *epp = &(enp->en_port);
104	efx_mcdi_req_t req;
105	uint8_t payload[MAX(MC_CMD_VADAPTOR_SET_MAC_IN_LEN,
106			    MC_CMD_VADAPTOR_SET_MAC_OUT_LEN)];
107	efx_rc_t rc;
108
109	(void) memset(payload, 0, sizeof (payload));
110	req.emr_cmd = MC_CMD_VADAPTOR_SET_MAC;
111	req.emr_in_buf = payload;
112	req.emr_in_length = MC_CMD_VADAPTOR_SET_MAC_IN_LEN;
113	req.emr_out_buf = payload;
114	req.emr_out_length = MC_CMD_VADAPTOR_SET_MAC_OUT_LEN;
115
116	MCDI_IN_SET_DWORD(req, VADAPTOR_SET_MAC_IN_UPSTREAM_PORT_ID,
117	    enp->en_vport_id);
118	EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, VADAPTOR_SET_MAC_IN_MACADDR),
119	    epp->ep_mac_addr);
120
121	efx_mcdi_execute(enp, &req);
122
123	if (req.emr_rc != 0) {
124		rc = req.emr_rc;
125		goto fail1;
126	}
127
128	return (0);
129
130fail1:
131	EFSYS_PROBE1(fail1, efx_rc_t, rc);
132
133	return (rc);
134}
135
136	__checkReturn	efx_rc_t
137ef10_mac_addr_set(
138	__in		efx_nic_t *enp)
139{
140	efx_rc_t rc;
141
142	if ((rc = efx_mcdi_vadapter_set_mac(enp)) != 0) {
143		if (rc != ENOTSUP)
144			goto fail1;
145
146		/*
147		 * Fallback for older Huntington firmware without Vadapter
148		 * support.
149		 */
150		if ((rc = ef10_mac_reconfigure(enp)) != 0)
151			goto fail2;
152	}
153
154	return (0);
155
156fail2:
157	EFSYS_PROBE(fail2);
158
159fail1:
160	EFSYS_PROBE1(fail1, efx_rc_t, rc);
161
162	return (rc);
163}
164
165static	__checkReturn	efx_rc_t
166efx_mcdi_mtu_set(
167	__in		efx_nic_t *enp,
168	__in		uint32_t mtu)
169{
170	efx_mcdi_req_t req;
171	uint8_t payload[MAX(MC_CMD_SET_MAC_EXT_IN_LEN,
172			    MC_CMD_SET_MAC_OUT_LEN)];
173	efx_rc_t rc;
174
175	(void) memset(payload, 0, sizeof (payload));
176	req.emr_cmd = MC_CMD_SET_MAC;
177	req.emr_in_buf = payload;
178	req.emr_in_length = MC_CMD_SET_MAC_EXT_IN_LEN;
179	req.emr_out_buf = payload;
180	req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN;
181
182	/* Only configure the MTU in this call to MC_CMD_SET_MAC */
183	MCDI_IN_SET_DWORD(req, SET_MAC_EXT_IN_MTU, mtu);
184	MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_EXT_IN_CONTROL,
185			    SET_MAC_EXT_IN_CFG_MTU, 1);
186
187	efx_mcdi_execute(enp, &req);
188
189	if (req.emr_rc != 0) {
190		rc = req.emr_rc;
191		goto fail1;
192	}
193
194	return (0);
195
196fail1:
197	EFSYS_PROBE1(fail1, efx_rc_t, rc);
198
199	return (rc);
200}
201
202	__checkReturn	efx_rc_t
203ef10_mac_pdu_set(
204	__in		efx_nic_t *enp)
205{
206	efx_port_t *epp = &(enp->en_port);
207	efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
208	efx_rc_t rc;
209
210	if (encp->enc_enhanced_set_mac_supported) {
211		if ((rc = efx_mcdi_mtu_set(enp, epp->ep_mac_pdu)) != 0)
212			goto fail1;
213	} else {
214		/*
215		 * Fallback for older Huntington firmware, which always
216		 * configure all of the parameters to MC_CMD_SET_MAC. This isn't
217		 * suitable for setting the MTU on unpriviliged functions.
218		 */
219		if ((rc = ef10_mac_reconfigure(enp)) != 0)
220			goto fail2;
221	}
222
223	return (0);
224
225fail2:
226	EFSYS_PROBE(fail2);
227fail1:
228	EFSYS_PROBE1(fail1, efx_rc_t, rc);
229
230	return (rc);
231}
232
233__checkReturn	efx_rc_t
234ef10_mac_reconfigure(
235	__in		efx_nic_t *enp)
236{
237	efx_port_t *epp = &(enp->en_port);
238	efx_mcdi_req_t req;
239	uint8_t payload[MAX(MC_CMD_SET_MAC_IN_LEN,
240			    MC_CMD_SET_MAC_OUT_LEN)];
241	efx_rc_t rc;
242
243	(void) memset(payload, 0, sizeof (payload));
244	req.emr_cmd = MC_CMD_SET_MAC;
245	req.emr_in_buf = payload;
246	req.emr_in_length = MC_CMD_SET_MAC_IN_LEN;
247	req.emr_out_buf = payload;
248	req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN;
249
250	MCDI_IN_SET_DWORD(req, SET_MAC_IN_MTU, epp->ep_mac_pdu);
251	MCDI_IN_SET_DWORD(req, SET_MAC_IN_DRAIN, epp->ep_mac_drain ? 1 : 0);
252	EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, SET_MAC_IN_ADDR),
253			    epp->ep_mac_addr);
254
255	/*
256	 * Note: The Huntington MAC does not support REJECT_BRDCST.
257	 * The REJECT_UNCST flag will also prevent multicast traffic
258	 * from reaching the filters. As Huntington filters drop any
259	 * traffic that does not match a filter it is ok to leave the
260	 * MAC running in promiscuous mode. See bug41141.
261	 *
262	 * FIXME: Does REJECT_UNCST behave the same way on Medford?
263	 */
264	MCDI_IN_POPULATE_DWORD_2(req, SET_MAC_IN_REJECT,
265				    SET_MAC_IN_REJECT_UNCST, 0,
266				    SET_MAC_IN_REJECT_BRDCST, 0);
267
268	/*
269	 * Flow control, whether it is auto-negotiated or not,
270	 * is set via the PHY advertised capabilities.  When set to
271	 * automatic the MAC will use the PHY settings to determine
272	 * the flow control settings.
273	 */
274	MCDI_IN_SET_DWORD(req, SET_MAC_IN_FCNTL, MC_CMD_FCNTL_AUTO);
275
276	/* Do not include the Ethernet frame checksum in RX packets */
277	MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_IN_FLAGS,
278				    SET_MAC_IN_FLAG_INCLUDE_FCS, 0);
279
280	efx_mcdi_execute_quiet(enp, &req);
281
282	if (req.emr_rc != 0) {
283		/*
284		 * Unprivileged functions cannot control link state,
285		 * but still need to configure filters.
286		 */
287		if (req.emr_rc != EACCES) {
288			rc = req.emr_rc;
289			goto fail1;
290		}
291	}
292
293	/*
294	 * Apply the filters for the MAC configuration.
295	 * If the NIC isn't ready to accept filters this may
296	 * return success without setting anything.
297	 */
298	rc = efx_filter_reconfigure(enp, epp->ep_mac_addr,
299				    epp->ep_all_unicst, epp->ep_mulcst,
300				    epp->ep_all_mulcst, epp->ep_brdcst,
301				    epp->ep_mulcst_addr_list,
302				    epp->ep_mulcst_addr_count);
303
304	return (0);
305
306fail1:
307	EFSYS_PROBE1(fail1, efx_rc_t, rc);
308
309	return (rc);
310}
311
312	__checkReturn			efx_rc_t
313ef10_mac_multicast_list_set(
314	__in				efx_nic_t *enp)
315{
316	efx_port_t *epp = &(enp->en_port);
317	efx_mac_ops_t *emop = epp->ep_emop;
318	efx_rc_t rc;
319
320	EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
321		    enp->en_family == EFX_FAMILY_MEDFORD);
322
323	if ((rc = emop->emo_reconfigure(enp)) != 0)
324		goto fail1;
325
326	return (0);
327
328fail1:
329	EFSYS_PROBE1(fail1, efx_rc_t, rc);
330
331	return (rc);
332}
333
334	__checkReturn	efx_rc_t
335ef10_mac_filter_default_rxq_set(
336	__in		efx_nic_t *enp,
337	__in		efx_rxq_t *erp,
338	__in		boolean_t using_rss)
339{
340	efx_port_t *epp = &(enp->en_port);
341	efx_rxq_t *old_rxq;
342	boolean_t old_using_rss;
343	efx_rc_t rc;
344
345	ef10_filter_get_default_rxq(enp, &old_rxq, &old_using_rss);
346
347	ef10_filter_default_rxq_set(enp, erp, using_rss);
348
349	rc = efx_filter_reconfigure(enp, epp->ep_mac_addr,
350				    epp->ep_all_unicst, epp->ep_mulcst,
351				    epp->ep_all_mulcst, epp->ep_brdcst,
352				    epp->ep_mulcst_addr_list,
353				    epp->ep_mulcst_addr_count);
354
355	if (rc != 0)
356		goto fail1;
357
358	return (0);
359
360fail1:
361	EFSYS_PROBE1(fail1, efx_rc_t, rc);
362
363	ef10_filter_default_rxq_set(enp, old_rxq, old_using_rss);
364
365	return (rc);
366}
367
368			void
369ef10_mac_filter_default_rxq_clear(
370	__in		efx_nic_t *enp)
371{
372	efx_port_t *epp = &(enp->en_port);
373
374	ef10_filter_default_rxq_clear(enp);
375
376	efx_filter_reconfigure(enp, epp->ep_mac_addr,
377				    epp->ep_all_unicst, epp->ep_mulcst,
378				    epp->ep_all_mulcst, epp->ep_brdcst,
379				    epp->ep_mulcst_addr_list,
380				    epp->ep_mulcst_addr_count);
381}
382
383
384#if EFSYS_OPT_LOOPBACK
385
386	__checkReturn	efx_rc_t
387ef10_mac_loopback_set(
388	__in		efx_nic_t *enp,
389	__in		efx_link_mode_t link_mode,
390	__in		efx_loopback_type_t loopback_type)
391{
392	efx_port_t *epp = &(enp->en_port);
393	efx_phy_ops_t *epop = epp->ep_epop;
394	efx_loopback_type_t old_loopback_type;
395	efx_link_mode_t old_loopback_link_mode;
396	efx_rc_t rc;
397
398	/* The PHY object handles this on EF10 */
399	old_loopback_type = epp->ep_loopback_type;
400	old_loopback_link_mode = epp->ep_loopback_link_mode;
401	epp->ep_loopback_type = loopback_type;
402	epp->ep_loopback_link_mode = link_mode;
403
404	if ((rc = epop->epo_reconfigure(enp)) != 0)
405		goto fail1;
406
407	return (0);
408
409fail1:
410	EFSYS_PROBE1(fail1, efx_rc_t, rc);
411
412	epp->ep_loopback_type = old_loopback_type;
413	epp->ep_loopback_link_mode = old_loopback_link_mode;
414
415	return (rc);
416}
417
418#endif	/* EFSYS_OPT_LOOPBACK */
419
420#if EFSYS_OPT_MAC_STATS
421
422#define	EF10_MAC_STAT_READ(_esmp, _field, _eqp)			\
423	EFSYS_MEM_READQ((_esmp), (_field) * sizeof (efx_qword_t), _eqp)
424
425
426	__checkReturn			efx_rc_t
427ef10_mac_stats_update(
428	__in				efx_nic_t *enp,
429	__in				efsys_mem_t *esmp,
430	__inout_ecount(EFX_MAC_NSTATS)	efsys_stat_t *stat,
431	__inout_opt			uint32_t *generationp)
432{
433	efx_qword_t value;
434	efx_qword_t generation_start;
435	efx_qword_t generation_end;
436
437	_NOTE(ARGUNUSED(enp))
438
439	/* Read END first so we don't race with the MC */
440	EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFX_MAC_STATS_SIZE);
441	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_GENERATION_END,
442			    &generation_end);
443	EFSYS_MEM_READ_BARRIER();
444
445	/* TX */
446	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PKTS, &value);
447	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value);
448
449	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_CONTROL_PKTS, &value);
450	EFSYS_STAT_SUBR_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value);
451
452	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PAUSE_PKTS, &value);
453	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PAUSE_PKTS]), &value);
454
455	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_UNICAST_PKTS, &value);
456	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_UNICST_PKTS]), &value);
457
458	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTICAST_PKTS, &value);
459	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULTICST_PKTS]), &value);
460
461	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BROADCAST_PKTS, &value);
462	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_BRDCST_PKTS]), &value);
463
464	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BYTES, &value);
465	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_OCTETS]), &value);
466
467	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LT64_PKTS, &value);
468	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value);
469	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_64_PKTS, &value);
470	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value);
471
472	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_65_TO_127_PKTS, &value);
473	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_65_TO_127_PKTS]), &value);
474
475	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_128_TO_255_PKTS, &value);
476	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_128_TO_255_PKTS]), &value);
477
478	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_256_TO_511_PKTS, &value);
479	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_256_TO_511_PKTS]), &value);
480
481	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_512_TO_1023_PKTS, &value);
482	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_512_TO_1023_PKTS]), &value);
483
484	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_1024_TO_15XX_PKTS, &value);
485	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_1024_TO_15XX_PKTS]), &value);
486
487	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_15XX_TO_JUMBO_PKTS, &value);
488	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value);
489	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_GTJUMBO_PKTS, &value);
490	EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value);
491
492	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BAD_FCS_PKTS, &value);
493	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_ERRORS]), &value);
494
495	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_SINGLE_COLLISION_PKTS, &value);
496	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_SGL_COL_PKTS]), &value);
497
498	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTIPLE_COLLISION_PKTS,
499			    &value);
500	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULT_COL_PKTS]), &value);
501
502	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_COLLISION_PKTS,
503			    &value);
504	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_COL_PKTS]), &value);
505
506	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LATE_COLLISION_PKTS, &value);
507	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LATE_COL_PKTS]), &value);
508
509	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_DEFERRED_PKTS, &value);
510	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_DEF_PKTS]), &value);
511
512	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_DEFERRED_PKTS,
513	    &value);
514	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_DEF_PKTS]), &value);
515
516	/* RX */
517	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BYTES, &value);
518	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_OCTETS]), &value);
519
520	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PKTS, &value);
521	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PKTS]), &value);
522
523	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNICAST_PKTS, &value);
524	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_UNICST_PKTS]), &value);
525
526	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MULTICAST_PKTS, &value);
527	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MULTICST_PKTS]), &value);
528
529	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BROADCAST_PKTS, &value);
530	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_BRDCST_PKTS]), &value);
531
532	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PAUSE_PKTS, &value);
533	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PAUSE_PKTS]), &value);
534
535	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNDERSIZE_PKTS, &value);
536	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value);
537	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_64_PKTS, &value);
538	EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value);
539
540	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_65_TO_127_PKTS, &value);
541	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_65_TO_127_PKTS]), &value);
542
543	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_128_TO_255_PKTS, &value);
544	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_128_TO_255_PKTS]), &value);
545
546	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_256_TO_511_PKTS, &value);
547	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_256_TO_511_PKTS]), &value);
548
549	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_512_TO_1023_PKTS, &value);
550	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_512_TO_1023_PKTS]), &value);
551
552	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_1024_TO_15XX_PKTS, &value);
553	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_1024_TO_15XX_PKTS]), &value);
554
555	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_15XX_TO_JUMBO_PKTS, &value);
556	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value);
557	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_GTJUMBO_PKTS, &value);
558	EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value);
559
560	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BAD_FCS_PKTS, &value);
561	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FCS_ERRORS]), &value);
562
563	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_OVERFLOW_PKTS, &value);
564	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_DROP_EVENTS]), &value);
565
566	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_FALSE_CARRIER_PKTS, &value);
567	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FALSE_CARRIER_ERRORS]), &value);
568
569	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_SYMBOL_ERROR_PKTS, &value);
570	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_SYMBOL_ERRORS]), &value);
571
572	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_ALIGN_ERROR_PKTS, &value);
573	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_ALIGN_ERRORS]), &value);
574
575	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_INTERNAL_ERROR_PKTS, &value);
576	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_INTERNAL_ERRORS]), &value);
577
578	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_JABBER_PKTS, &value);
579	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_JABBER_PKTS]), &value);
580
581	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_CHAR_ERR, &value);
582	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_CHAR_ERR]),
583			    &(value.eq_dword[0]));
584	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_CHAR_ERR]),
585			    &(value.eq_dword[1]));
586
587	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_CHAR_ERR, &value);
588	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_CHAR_ERR]),
589			    &(value.eq_dword[0]));
590	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_CHAR_ERR]),
591			    &(value.eq_dword[1]));
592
593	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_DISP_ERR, &value);
594	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_DISP_ERR]),
595			    &(value.eq_dword[0]));
596	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_DISP_ERR]),
597			    &(value.eq_dword[1]));
598
599	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_DISP_ERR, &value);
600	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_DISP_ERR]),
601			    &(value.eq_dword[0]));
602	EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_DISP_ERR]),
603			    &(value.eq_dword[1]));
604
605	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MATCH_FAULT, &value);
606	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MATCH_FAULT]), &value);
607
608	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_NODESC_DROPS, &value);
609	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_NODESC_DROP_CNT]), &value);
610
611	/* Packet memory (EF10 only) */
612	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_BB_OVERFLOW, &value);
613	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_BB_OVERFLOW]), &value);
614
615	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_BB_OVERFLOW, &value);
616	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_BB_OVERFLOW]), &value);
617
618	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_VFIFO_FULL, &value);
619	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_VFIFO_FULL]), &value);
620
621	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_VFIFO_FULL, &value);
622	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_VFIFO_FULL]), &value);
623
624	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_QBB, &value);
625	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_QBB]), &value);
626
627	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_QBB, &value);
628	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_QBB]), &value);
629
630	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_MAPPING, &value);
631	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_MAPPING]), &value);
632
633	/* RX datapath */
634	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_Q_DISABLED_PKTS, &value);
635	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_Q_DISABLED_PKTS]), &value);
636
637	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_DI_DROPPED_PKTS, &value);
638	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_DI_DROPPED_PKTS]), &value);
639
640	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_STREAMING_PKTS, &value);
641	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_STREAMING_PKTS]), &value);
642
643	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_FETCH_CONDITIONS, &value);
644	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_FETCH]), &value);
645
646	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_WAIT_CONDITIONS, &value);
647	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_WAIT]), &value);
648
649
650	/* VADAPTER RX */
651	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_PACKETS,
652	    &value);
653	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_PACKETS]),
654	    &value);
655
656	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_BYTES,
657	    &value);
658	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_BYTES]),
659	    &value);
660
661	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_PACKETS,
662	    &value);
663	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_PACKETS]),
664	    &value);
665
666	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_BYTES,
667	    &value);
668	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_BYTES]),
669	    &value);
670
671	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_PACKETS,
672	    &value);
673	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_PACKETS]),
674	    &value);
675
676	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_BYTES,
677	    &value);
678	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_BYTES]),
679	    &value);
680
681	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_PACKETS,
682	    &value);
683	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_PACKETS]),
684	    &value);
685
686	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_BYTES, &value);
687	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_BYTES]), &value);
688
689	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_OVERFLOW, &value);
690	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_OVERFLOW]), &value);
691
692	/* VADAPTER TX */
693	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_PACKETS,
694	    &value);
695	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_PACKETS]),
696	    &value);
697
698	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_BYTES,
699	    &value);
700	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_BYTES]),
701	    &value);
702
703	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_PACKETS,
704	    &value);
705	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_PACKETS]),
706	    &value);
707
708	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_BYTES,
709	    &value);
710	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_BYTES]),
711	    &value);
712
713	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_PACKETS,
714	    &value);
715	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_PACKETS]),
716	    &value);
717
718	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_BYTES,
719	    &value);
720	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_BYTES]),
721	    &value);
722
723	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_PACKETS, &value);
724	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_PACKETS]), &value);
725
726	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_BYTES, &value);
727	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_BYTES]), &value);
728
729	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_OVERFLOW, &value);
730	EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_OVERFLOW]), &value);
731
732
733	EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFX_MAC_STATS_SIZE);
734	EFSYS_MEM_READ_BARRIER();
735	EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_GENERATION_START,
736			    &generation_start);
737
738	/* Check that we didn't read the stats in the middle of a DMA */
739	/* Not a good enough check ? */
740	if (memcmp(&generation_start, &generation_end,
741	    sizeof (generation_start)))
742		return (EAGAIN);
743
744	if (generationp)
745		*generationp = EFX_QWORD_FIELD(generation_start, EFX_DWORD_0);
746
747	return (0);
748}
749
750#endif	/* EFSYS_OPT_MAC_STATS */
751
752#endif	/* EFSYS_OPT_HUNTINGTON */
753