xref: /freebsd/sys/dev/sfxge/common/efx_mac.c (revision f6a3b357e9be4c6423c85eff9a847163a0d307c8)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2007-2016 Solarflare Communications Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright notice,
11  *    this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright notice,
13  *    this list of conditions and the following disclaimer in the documentation
14  *    and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
18  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
26  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * The views and conclusions contained in the software and documentation are
29  * those of the authors and should not be interpreted as representing official
30  * policies, either expressed or implied, of the FreeBSD Project.
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include "efx.h"
37 #include "efx_impl.h"
38 
39 #if EFSYS_OPT_SIENA
40 
41 static	__checkReturn	efx_rc_t
42 siena_mac_multicast_list_set(
43 	__in		efx_nic_t *enp);
44 
45 #endif /* EFSYS_OPT_SIENA */
46 
47 #if EFSYS_OPT_SIENA
48 static const efx_mac_ops_t	__efx_mac_siena_ops = {
49 	siena_mac_poll,				/* emo_poll */
50 	siena_mac_up,				/* emo_up */
51 	siena_mac_reconfigure,			/* emo_addr_set */
52 	siena_mac_reconfigure,			/* emo_pdu_set */
53 	siena_mac_pdu_get,			/* emo_pdu_get */
54 	siena_mac_reconfigure,			/* emo_reconfigure */
55 	siena_mac_multicast_list_set,		/* emo_multicast_list_set */
56 	NULL,					/* emo_filter_set_default_rxq */
57 	NULL,				/* emo_filter_default_rxq_clear */
58 #if EFSYS_OPT_LOOPBACK
59 	siena_mac_loopback_set,			/* emo_loopback_set */
60 #endif	/* EFSYS_OPT_LOOPBACK */
61 #if EFSYS_OPT_MAC_STATS
62 	siena_mac_stats_get_mask,		/* emo_stats_get_mask */
63 	efx_mcdi_mac_stats_clear,		/* emo_stats_clear */
64 	efx_mcdi_mac_stats_upload,		/* emo_stats_upload */
65 	efx_mcdi_mac_stats_periodic,		/* emo_stats_periodic */
66 	siena_mac_stats_update			/* emo_stats_update */
67 #endif	/* EFSYS_OPT_MAC_STATS */
68 };
69 #endif	/* EFSYS_OPT_SIENA */
70 
71 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
72 static const efx_mac_ops_t	__efx_mac_ef10_ops = {
73 	ef10_mac_poll,				/* emo_poll */
74 	ef10_mac_up,				/* emo_up */
75 	ef10_mac_addr_set,			/* emo_addr_set */
76 	ef10_mac_pdu_set,			/* emo_pdu_set */
77 	ef10_mac_pdu_get,			/* emo_pdu_get */
78 	ef10_mac_reconfigure,			/* emo_reconfigure */
79 	ef10_mac_multicast_list_set,		/* emo_multicast_list_set */
80 	ef10_mac_filter_default_rxq_set,	/* emo_filter_default_rxq_set */
81 	ef10_mac_filter_default_rxq_clear,
82 					/* emo_filter_default_rxq_clear */
83 #if EFSYS_OPT_LOOPBACK
84 	ef10_mac_loopback_set,			/* emo_loopback_set */
85 #endif	/* EFSYS_OPT_LOOPBACK */
86 #if EFSYS_OPT_MAC_STATS
87 	ef10_mac_stats_get_mask,		/* emo_stats_get_mask */
88 	efx_mcdi_mac_stats_clear,		/* emo_stats_clear */
89 	efx_mcdi_mac_stats_upload,		/* emo_stats_upload */
90 	efx_mcdi_mac_stats_periodic,		/* emo_stats_periodic */
91 	ef10_mac_stats_update			/* emo_stats_update */
92 #endif	/* EFSYS_OPT_MAC_STATS */
93 };
94 #endif	/* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */
95 
96 	__checkReturn			efx_rc_t
97 efx_mac_pdu_set(
98 	__in				efx_nic_t *enp,
99 	__in				size_t pdu)
100 {
101 	efx_port_t *epp = &(enp->en_port);
102 	const efx_mac_ops_t *emop = epp->ep_emop;
103 	uint32_t old_pdu;
104 	efx_rc_t rc;
105 
106 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
107 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
108 	EFSYS_ASSERT(emop != NULL);
109 
110 	if (pdu < EFX_MAC_PDU_MIN) {
111 		rc = EINVAL;
112 		goto fail1;
113 	}
114 
115 	if (pdu > EFX_MAC_PDU_MAX) {
116 		rc = EINVAL;
117 		goto fail2;
118 	}
119 
120 	old_pdu = epp->ep_mac_pdu;
121 	epp->ep_mac_pdu = (uint32_t)pdu;
122 	if ((rc = emop->emo_pdu_set(enp)) != 0)
123 		goto fail3;
124 
125 	return (0);
126 
127 fail3:
128 	EFSYS_PROBE(fail3);
129 
130 	epp->ep_mac_pdu = old_pdu;
131 
132 fail2:
133 	EFSYS_PROBE(fail2);
134 fail1:
135 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
136 
137 	return (rc);
138 }
139 
140 	__checkReturn	efx_rc_t
141 efx_mac_pdu_get(
142 	__in		efx_nic_t *enp,
143 	__out		size_t *pdu)
144 {
145 	efx_port_t *epp = &(enp->en_port);
146 	const efx_mac_ops_t *emop = epp->ep_emop;
147 	efx_rc_t rc;
148 
149 	if ((rc = emop->emo_pdu_get(enp, pdu)) != 0)
150 		goto fail1;
151 
152 	return (0);
153 
154 fail1:
155 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
156 
157 	return (rc);
158 }
159 
160 	__checkReturn			efx_rc_t
161 efx_mac_addr_set(
162 	__in				efx_nic_t *enp,
163 	__in				uint8_t *addr)
164 {
165 	efx_port_t *epp = &(enp->en_port);
166 	const efx_mac_ops_t *emop = epp->ep_emop;
167 	uint8_t old_addr[6];
168 	uint32_t oui;
169 	efx_rc_t rc;
170 
171 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
172 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
173 
174 	if (EFX_MAC_ADDR_IS_MULTICAST(addr)) {
175 		rc = EINVAL;
176 		goto fail1;
177 	}
178 
179 	oui = addr[0] << 16 | addr[1] << 8 | addr[2];
180 	if (oui == 0x000000) {
181 		rc = EINVAL;
182 		goto fail2;
183 	}
184 
185 	EFX_MAC_ADDR_COPY(old_addr, epp->ep_mac_addr);
186 	EFX_MAC_ADDR_COPY(epp->ep_mac_addr, addr);
187 	if ((rc = emop->emo_addr_set(enp)) != 0)
188 		goto fail3;
189 
190 	return (0);
191 
192 fail3:
193 	EFSYS_PROBE(fail3);
194 
195 	EFX_MAC_ADDR_COPY(epp->ep_mac_addr, old_addr);
196 
197 fail2:
198 	EFSYS_PROBE(fail2);
199 fail1:
200 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
201 
202 	return (rc);
203 }
204 
205 	__checkReturn			efx_rc_t
206 efx_mac_filter_set(
207 	__in				efx_nic_t *enp,
208 	__in				boolean_t all_unicst,
209 	__in				boolean_t mulcst,
210 	__in				boolean_t all_mulcst,
211 	__in				boolean_t brdcst)
212 {
213 	efx_port_t *epp = &(enp->en_port);
214 	const efx_mac_ops_t *emop = epp->ep_emop;
215 	boolean_t old_all_unicst;
216 	boolean_t old_mulcst;
217 	boolean_t old_all_mulcst;
218 	boolean_t old_brdcst;
219 	efx_rc_t rc;
220 
221 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
222 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
223 
224 	old_all_unicst = epp->ep_all_unicst;
225 	old_mulcst = epp->ep_mulcst;
226 	old_all_mulcst = epp->ep_all_mulcst;
227 	old_brdcst = epp->ep_brdcst;
228 
229 	epp->ep_all_unicst = all_unicst;
230 	epp->ep_mulcst = mulcst;
231 	epp->ep_all_mulcst = all_mulcst;
232 	epp->ep_brdcst = brdcst;
233 
234 	if ((rc = emop->emo_reconfigure(enp)) != 0)
235 		goto fail1;
236 
237 	return (0);
238 
239 fail1:
240 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
241 
242 	epp->ep_all_unicst = old_all_unicst;
243 	epp->ep_mulcst = old_mulcst;
244 	epp->ep_all_mulcst = old_all_mulcst;
245 	epp->ep_brdcst = old_brdcst;
246 
247 	return (rc);
248 }
249 
250 	__checkReturn			efx_rc_t
251 efx_mac_drain(
252 	__in				efx_nic_t *enp,
253 	__in				boolean_t enabled)
254 {
255 	efx_port_t *epp = &(enp->en_port);
256 	const efx_mac_ops_t *emop = epp->ep_emop;
257 	efx_rc_t rc;
258 
259 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
260 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
261 	EFSYS_ASSERT(emop != NULL);
262 
263 	if (epp->ep_mac_drain == enabled)
264 		return (0);
265 
266 	epp->ep_mac_drain = enabled;
267 
268 	if ((rc = emop->emo_reconfigure(enp)) != 0)
269 		goto fail1;
270 
271 	return (0);
272 
273 fail1:
274 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
275 
276 	return (rc);
277 }
278 
279 	__checkReturn	efx_rc_t
280 efx_mac_up(
281 	__in		efx_nic_t *enp,
282 	__out		boolean_t *mac_upp)
283 {
284 	efx_port_t *epp = &(enp->en_port);
285 	const efx_mac_ops_t *emop = epp->ep_emop;
286 	efx_rc_t rc;
287 
288 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
289 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
290 
291 	if ((rc = emop->emo_up(enp, mac_upp)) != 0)
292 		goto fail1;
293 
294 	return (0);
295 
296 fail1:
297 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
298 
299 	return (rc);
300 }
301 
302 	__checkReturn			efx_rc_t
303 efx_mac_fcntl_set(
304 	__in				efx_nic_t *enp,
305 	__in				unsigned int fcntl,
306 	__in				boolean_t autoneg)
307 {
308 	efx_port_t *epp = &(enp->en_port);
309 	const efx_mac_ops_t *emop = epp->ep_emop;
310 	const efx_phy_ops_t *epop = epp->ep_epop;
311 	unsigned int old_fcntl;
312 	boolean_t old_autoneg;
313 	unsigned int old_adv_cap;
314 	efx_rc_t rc;
315 
316 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
317 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
318 
319 	if ((fcntl & ~(EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE)) != 0) {
320 		rc = EINVAL;
321 		goto fail1;
322 	}
323 
324 	/*
325 	 * Ignore a request to set flow control auto-negotiation
326 	 * if the PHY doesn't support it.
327 	 */
328 	if (~epp->ep_phy_cap_mask & (1 << EFX_PHY_CAP_AN))
329 		autoneg = B_FALSE;
330 
331 	old_fcntl = epp->ep_fcntl;
332 	old_autoneg = epp->ep_fcntl_autoneg;
333 	old_adv_cap = epp->ep_adv_cap_mask;
334 
335 	epp->ep_fcntl = fcntl;
336 	epp->ep_fcntl_autoneg = autoneg;
337 
338 	/*
339 	 * Always encode the flow control settings in the advertised
340 	 * capabilities even if we are not trying to auto-negotiate
341 	 * them and reconfigure both the PHY and the MAC.
342 	 */
343 	if (fcntl & EFX_FCNTL_RESPOND)
344 		epp->ep_adv_cap_mask |=    (1 << EFX_PHY_CAP_PAUSE |
345 					    1 << EFX_PHY_CAP_ASYM);
346 	else
347 		epp->ep_adv_cap_mask &=   ~(1 << EFX_PHY_CAP_PAUSE |
348 					    1 << EFX_PHY_CAP_ASYM);
349 
350 	if (fcntl & EFX_FCNTL_GENERATE)
351 		epp->ep_adv_cap_mask ^= (1 << EFX_PHY_CAP_ASYM);
352 
353 	if ((rc = epop->epo_reconfigure(enp)) != 0)
354 		goto fail2;
355 
356 	if ((rc = emop->emo_reconfigure(enp)) != 0)
357 		goto fail3;
358 
359 	return (0);
360 
361 fail3:
362 	EFSYS_PROBE(fail3);
363 
364 fail2:
365 	EFSYS_PROBE(fail2);
366 
367 	epp->ep_fcntl = old_fcntl;
368 	epp->ep_fcntl_autoneg = old_autoneg;
369 	epp->ep_adv_cap_mask = old_adv_cap;
370 
371 fail1:
372 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
373 
374 	return (rc);
375 }
376 
377 			void
378 efx_mac_fcntl_get(
379 	__in		efx_nic_t *enp,
380 	__out		unsigned int *fcntl_wantedp,
381 	__out		unsigned int *fcntl_linkp)
382 {
383 	efx_port_t *epp = &(enp->en_port);
384 	unsigned int wanted = 0;
385 
386 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
387 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
388 
389 	/*
390 	 * Decode the requested flow control settings from the PHY
391 	 * advertised capabilities.
392 	 */
393 	if (epp->ep_adv_cap_mask & (1 << EFX_PHY_CAP_PAUSE))
394 		wanted = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE;
395 	if (epp->ep_adv_cap_mask & (1 << EFX_PHY_CAP_ASYM))
396 		wanted ^= EFX_FCNTL_GENERATE;
397 
398 	*fcntl_linkp = epp->ep_fcntl;
399 	*fcntl_wantedp = wanted;
400 }
401 
402 	__checkReturn	efx_rc_t
403 efx_mac_multicast_list_set(
404 	__in				efx_nic_t *enp,
405 	__in_ecount(6*count)		uint8_t const *addrs,
406 	__in				int count)
407 {
408 	efx_port_t *epp = &(enp->en_port);
409 	const efx_mac_ops_t *emop = epp->ep_emop;
410 	uint8_t	*old_mulcst_addr_list = NULL;
411 	uint32_t old_mulcst_addr_count;
412 	efx_rc_t rc;
413 
414 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
415 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
416 
417 	if (count > EFX_MAC_MULTICAST_LIST_MAX) {
418 		rc = EINVAL;
419 		goto fail1;
420 	}
421 
422 	old_mulcst_addr_count = epp->ep_mulcst_addr_count;
423 	if (old_mulcst_addr_count > 0) {
424 		/* Allocate memory to store old list (instead of using stack) */
425 		EFSYS_KMEM_ALLOC(enp->en_esip,
426 				old_mulcst_addr_count * EFX_MAC_ADDR_LEN,
427 				old_mulcst_addr_list);
428 		if (old_mulcst_addr_list == NULL) {
429 			rc = ENOMEM;
430 			goto fail2;
431 		}
432 
433 		/* Save the old list in case we need to rollback */
434 		memcpy(old_mulcst_addr_list, epp->ep_mulcst_addr_list,
435 			old_mulcst_addr_count * EFX_MAC_ADDR_LEN);
436 	}
437 
438 	/* Store the new list */
439 	memcpy(epp->ep_mulcst_addr_list, addrs,
440 		count * EFX_MAC_ADDR_LEN);
441 	epp->ep_mulcst_addr_count = count;
442 
443 	if ((rc = emop->emo_multicast_list_set(enp)) != 0)
444 		goto fail3;
445 
446 	if (old_mulcst_addr_count > 0) {
447 		EFSYS_KMEM_FREE(enp->en_esip,
448 				old_mulcst_addr_count * EFX_MAC_ADDR_LEN,
449 				old_mulcst_addr_list);
450 	}
451 
452 	return (0);
453 
454 fail3:
455 	EFSYS_PROBE(fail3);
456 
457 	/* Restore original list on failure */
458 	epp->ep_mulcst_addr_count = old_mulcst_addr_count;
459 	if (old_mulcst_addr_count > 0) {
460 		memcpy(epp->ep_mulcst_addr_list, old_mulcst_addr_list,
461 			old_mulcst_addr_count * EFX_MAC_ADDR_LEN);
462 
463 		EFSYS_KMEM_FREE(enp->en_esip,
464 				old_mulcst_addr_count * EFX_MAC_ADDR_LEN,
465 				old_mulcst_addr_list);
466 	}
467 
468 fail2:
469 	EFSYS_PROBE(fail2);
470 
471 fail1:
472 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
473 
474 	return (rc);
475 
476 }
477 
478 	__checkReturn	efx_rc_t
479 efx_mac_filter_default_rxq_set(
480 	__in		efx_nic_t *enp,
481 	__in		efx_rxq_t *erp,
482 	__in		boolean_t using_rss)
483 {
484 	efx_port_t *epp = &(enp->en_port);
485 	const efx_mac_ops_t *emop = epp->ep_emop;
486 	efx_rc_t rc;
487 
488 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
489 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
490 
491 	if (emop->emo_filter_default_rxq_set != NULL) {
492 		rc = emop->emo_filter_default_rxq_set(enp, erp, using_rss);
493 		if (rc != 0)
494 			goto fail1;
495 	}
496 
497 	return (0);
498 
499 fail1:
500 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
501 
502 	return (rc);
503 }
504 
505 			void
506 efx_mac_filter_default_rxq_clear(
507 	__in		efx_nic_t *enp)
508 {
509 	efx_port_t *epp = &(enp->en_port);
510 	const efx_mac_ops_t *emop = epp->ep_emop;
511 
512 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
513 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
514 
515 	if (emop->emo_filter_default_rxq_clear != NULL)
516 		emop->emo_filter_default_rxq_clear(enp);
517 }
518 
519 
520 #if EFSYS_OPT_MAC_STATS
521 
522 #if EFSYS_OPT_NAMES
523 
524 /* START MKCONFIG GENERATED EfxMacStatNamesBlock 1a45a82fcfb30c1b */
525 static const char * const __efx_mac_stat_name[] = {
526 	"rx_octets",
527 	"rx_pkts",
528 	"rx_unicst_pkts",
529 	"rx_multicst_pkts",
530 	"rx_brdcst_pkts",
531 	"rx_pause_pkts",
532 	"rx_le_64_pkts",
533 	"rx_65_to_127_pkts",
534 	"rx_128_to_255_pkts",
535 	"rx_256_to_511_pkts",
536 	"rx_512_to_1023_pkts",
537 	"rx_1024_to_15xx_pkts",
538 	"rx_ge_15xx_pkts",
539 	"rx_errors",
540 	"rx_fcs_errors",
541 	"rx_drop_events",
542 	"rx_false_carrier_errors",
543 	"rx_symbol_errors",
544 	"rx_align_errors",
545 	"rx_internal_errors",
546 	"rx_jabber_pkts",
547 	"rx_lane0_char_err",
548 	"rx_lane1_char_err",
549 	"rx_lane2_char_err",
550 	"rx_lane3_char_err",
551 	"rx_lane0_disp_err",
552 	"rx_lane1_disp_err",
553 	"rx_lane2_disp_err",
554 	"rx_lane3_disp_err",
555 	"rx_match_fault",
556 	"rx_nodesc_drop_cnt",
557 	"tx_octets",
558 	"tx_pkts",
559 	"tx_unicst_pkts",
560 	"tx_multicst_pkts",
561 	"tx_brdcst_pkts",
562 	"tx_pause_pkts",
563 	"tx_le_64_pkts",
564 	"tx_65_to_127_pkts",
565 	"tx_128_to_255_pkts",
566 	"tx_256_to_511_pkts",
567 	"tx_512_to_1023_pkts",
568 	"tx_1024_to_15xx_pkts",
569 	"tx_ge_15xx_pkts",
570 	"tx_errors",
571 	"tx_sgl_col_pkts",
572 	"tx_mult_col_pkts",
573 	"tx_ex_col_pkts",
574 	"tx_late_col_pkts",
575 	"tx_def_pkts",
576 	"tx_ex_def_pkts",
577 	"pm_trunc_bb_overflow",
578 	"pm_discard_bb_overflow",
579 	"pm_trunc_vfifo_full",
580 	"pm_discard_vfifo_full",
581 	"pm_trunc_qbb",
582 	"pm_discard_qbb",
583 	"pm_discard_mapping",
584 	"rxdp_q_disabled_pkts",
585 	"rxdp_di_dropped_pkts",
586 	"rxdp_streaming_pkts",
587 	"rxdp_hlb_fetch",
588 	"rxdp_hlb_wait",
589 	"vadapter_rx_unicast_packets",
590 	"vadapter_rx_unicast_bytes",
591 	"vadapter_rx_multicast_packets",
592 	"vadapter_rx_multicast_bytes",
593 	"vadapter_rx_broadcast_packets",
594 	"vadapter_rx_broadcast_bytes",
595 	"vadapter_rx_bad_packets",
596 	"vadapter_rx_bad_bytes",
597 	"vadapter_rx_overflow",
598 	"vadapter_tx_unicast_packets",
599 	"vadapter_tx_unicast_bytes",
600 	"vadapter_tx_multicast_packets",
601 	"vadapter_tx_multicast_bytes",
602 	"vadapter_tx_broadcast_packets",
603 	"vadapter_tx_broadcast_bytes",
604 	"vadapter_tx_bad_packets",
605 	"vadapter_tx_bad_bytes",
606 	"vadapter_tx_overflow",
607 	"fec_uncorrected_errors",
608 	"fec_corrected_errors",
609 	"fec_corrected_symbols_lane0",
610 	"fec_corrected_symbols_lane1",
611 	"fec_corrected_symbols_lane2",
612 	"fec_corrected_symbols_lane3",
613 	"ctpio_vi_busy_fallback",
614 	"ctpio_long_write_success",
615 	"ctpio_missing_dbell_fail",
616 	"ctpio_overflow_fail",
617 	"ctpio_underflow_fail",
618 	"ctpio_timeout_fail",
619 	"ctpio_noncontig_wr_fail",
620 	"ctpio_frm_clobber_fail",
621 	"ctpio_invalid_wr_fail",
622 	"ctpio_vi_clobber_fallback",
623 	"ctpio_unqualified_fallback",
624 	"ctpio_runt_fallback",
625 	"ctpio_success",
626 	"ctpio_fallback",
627 	"ctpio_poison",
628 	"ctpio_erase",
629 	"rxdp_scatter_disabled_trunc",
630 	"rxdp_hlb_idle",
631 	"rxdp_hlb_timeout",
632 };
633 /* END MKCONFIG GENERATED EfxMacStatNamesBlock */
634 
635 	__checkReturn			const char *
636 efx_mac_stat_name(
637 	__in				efx_nic_t *enp,
638 	__in				unsigned int id)
639 {
640 	_NOTE(ARGUNUSED(enp))
641 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
642 
643 	EFSYS_ASSERT3U(id, <, EFX_MAC_NSTATS);
644 	return (__efx_mac_stat_name[id]);
645 }
646 
647 #endif	/* EFSYS_OPT_NAMES */
648 
649 static					efx_rc_t
650 efx_mac_stats_mask_add_range(
651 	__inout_bcount(mask_size)	uint32_t *maskp,
652 	__in				size_t mask_size,
653 	__in				const struct efx_mac_stats_range *rngp)
654 {
655 	unsigned int mask_npages = mask_size / sizeof (*maskp);
656 	unsigned int el;
657 	unsigned int el_min;
658 	unsigned int el_max;
659 	unsigned int low;
660 	unsigned int high;
661 	unsigned int width;
662 	efx_rc_t rc;
663 
664 	if ((mask_npages * EFX_MAC_STATS_MASK_BITS_PER_PAGE) <=
665 	    (unsigned int)rngp->last) {
666 		rc = EINVAL;
667 		goto fail1;
668 	}
669 
670 	EFSYS_ASSERT3U(rngp->first, <=, rngp->last);
671 	EFSYS_ASSERT3U(rngp->last, <, EFX_MAC_NSTATS);
672 
673 	for (el = 0; el < mask_npages; ++el) {
674 		el_min = el * EFX_MAC_STATS_MASK_BITS_PER_PAGE;
675 		el_max =
676 		    el_min + (EFX_MAC_STATS_MASK_BITS_PER_PAGE - 1);
677 		if ((unsigned int)rngp->first > el_max ||
678 		    (unsigned int)rngp->last < el_min)
679 			continue;
680 		low = MAX((unsigned int)rngp->first, el_min);
681 		high = MIN((unsigned int)rngp->last, el_max);
682 		width = high - low + 1;
683 		maskp[el] |=
684 		    (width == EFX_MAC_STATS_MASK_BITS_PER_PAGE) ?
685 		    (~0ULL) : (((1ULL << width) - 1) << (low - el_min));
686 	}
687 
688 	return (0);
689 
690 fail1:
691 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
692 
693 	return (rc);
694 }
695 
696 					efx_rc_t
697 efx_mac_stats_mask_add_ranges(
698 	__inout_bcount(mask_size)	uint32_t *maskp,
699 	__in				size_t mask_size,
700 	__in_ecount(rng_count)		const struct efx_mac_stats_range *rngp,
701 	__in				unsigned int rng_count)
702 {
703 	unsigned int i;
704 	efx_rc_t rc;
705 
706 	for (i = 0; i < rng_count; ++i) {
707 		if ((rc = efx_mac_stats_mask_add_range(maskp, mask_size,
708 		    &rngp[i])) != 0)
709 			goto fail1;
710 	}
711 
712 	return (0);
713 
714 fail1:
715 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
716 
717 	return (rc);
718 }
719 
720 	__checkReturn			efx_rc_t
721 efx_mac_stats_get_mask(
722 	__in				efx_nic_t *enp,
723 	__out_bcount(mask_size)		uint32_t *maskp,
724 	__in				size_t mask_size)
725 {
726 	efx_port_t *epp = &(enp->en_port);
727 	const efx_mac_ops_t *emop = epp->ep_emop;
728 	efx_rc_t rc;
729 
730 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
731 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
732 	EFSYS_ASSERT(maskp != NULL);
733 	EFSYS_ASSERT(mask_size % sizeof (maskp[0]) == 0);
734 
735 	(void) memset(maskp, 0, mask_size);
736 
737 	if ((rc = emop->emo_stats_get_mask(enp, maskp, mask_size)) != 0)
738 		goto fail1;
739 
740 	return (0);
741 
742 fail1:
743 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
744 
745 	return (rc);
746 }
747 
748 	__checkReturn			efx_rc_t
749 efx_mac_stats_clear(
750 	__in				efx_nic_t *enp)
751 {
752 	efx_port_t *epp = &(enp->en_port);
753 	const efx_mac_ops_t *emop = epp->ep_emop;
754 	efx_rc_t rc;
755 
756 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
757 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
758 	EFSYS_ASSERT(emop != NULL);
759 
760 	if ((rc = emop->emo_stats_clear(enp)) != 0)
761 		goto fail1;
762 
763 	return (0);
764 
765 fail1:
766 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
767 
768 	return (rc);
769 }
770 
771 	__checkReturn			efx_rc_t
772 efx_mac_stats_upload(
773 	__in				efx_nic_t *enp,
774 	__in				efsys_mem_t *esmp)
775 {
776 	efx_port_t *epp = &(enp->en_port);
777 	const efx_mac_ops_t *emop = epp->ep_emop;
778 	efx_rc_t rc;
779 
780 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
781 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
782 	EFSYS_ASSERT(emop != NULL);
783 
784 	if ((rc = emop->emo_stats_upload(enp, esmp)) != 0)
785 		goto fail1;
786 
787 	return (0);
788 
789 fail1:
790 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
791 
792 	return (rc);
793 }
794 
795 	__checkReturn			efx_rc_t
796 efx_mac_stats_periodic(
797 	__in				efx_nic_t *enp,
798 	__in				efsys_mem_t *esmp,
799 	__in				uint16_t period_ms,
800 	__in				boolean_t events)
801 {
802 	efx_port_t *epp = &(enp->en_port);
803 	const efx_mac_ops_t *emop = epp->ep_emop;
804 	efx_rc_t rc;
805 
806 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
807 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
808 
809 	EFSYS_ASSERT(emop != NULL);
810 
811 	if (emop->emo_stats_periodic == NULL) {
812 		rc = EINVAL;
813 		goto fail1;
814 	}
815 
816 	if ((rc = emop->emo_stats_periodic(enp, esmp, period_ms, events)) != 0)
817 		goto fail2;
818 
819 	return (0);
820 
821 fail2:
822 	EFSYS_PROBE(fail2);
823 fail1:
824 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
825 
826 	return (rc);
827 }
828 
829 
830 	__checkReturn			efx_rc_t
831 efx_mac_stats_update(
832 	__in				efx_nic_t *enp,
833 	__in				efsys_mem_t *esmp,
834 	__inout_ecount(EFX_MAC_NSTATS)	efsys_stat_t *essp,
835 	__inout_opt			uint32_t *generationp)
836 {
837 	efx_port_t *epp = &(enp->en_port);
838 	const efx_mac_ops_t *emop = epp->ep_emop;
839 	efx_rc_t rc;
840 
841 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
842 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
843 	EFSYS_ASSERT(emop != NULL);
844 
845 	rc = emop->emo_stats_update(enp, esmp, essp, generationp);
846 
847 	return (rc);
848 }
849 
850 #endif	/* EFSYS_OPT_MAC_STATS */
851 
852 	__checkReturn			efx_rc_t
853 efx_mac_select(
854 	__in				efx_nic_t *enp)
855 {
856 	efx_port_t *epp = &(enp->en_port);
857 	efx_mac_type_t type = EFX_MAC_INVALID;
858 	const efx_mac_ops_t *emop;
859 	int rc = EINVAL;
860 
861 	switch (enp->en_family) {
862 #if EFSYS_OPT_SIENA
863 	case EFX_FAMILY_SIENA:
864 		emop = &__efx_mac_siena_ops;
865 		type = EFX_MAC_SIENA;
866 		break;
867 #endif /* EFSYS_OPT_SIENA */
868 
869 #if EFSYS_OPT_HUNTINGTON
870 	case EFX_FAMILY_HUNTINGTON:
871 		emop = &__efx_mac_ef10_ops;
872 		type = EFX_MAC_HUNTINGTON;
873 		break;
874 #endif /* EFSYS_OPT_HUNTINGTON */
875 
876 #if EFSYS_OPT_MEDFORD
877 	case EFX_FAMILY_MEDFORD:
878 		emop = &__efx_mac_ef10_ops;
879 		type = EFX_MAC_MEDFORD;
880 		break;
881 #endif /* EFSYS_OPT_MEDFORD */
882 
883 #if EFSYS_OPT_MEDFORD2
884 	case EFX_FAMILY_MEDFORD2:
885 		emop = &__efx_mac_ef10_ops;
886 		type = EFX_MAC_MEDFORD2;
887 		break;
888 #endif /* EFSYS_OPT_MEDFORD2 */
889 
890 	default:
891 		rc = EINVAL;
892 		goto fail1;
893 	}
894 
895 	EFSYS_ASSERT(type != EFX_MAC_INVALID);
896 	EFSYS_ASSERT3U(type, <, EFX_MAC_NTYPES);
897 	EFSYS_ASSERT(emop != NULL);
898 
899 	epp->ep_emop = emop;
900 	epp->ep_mac_type = type;
901 
902 	return (0);
903 
904 fail1:
905 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
906 
907 	return (rc);
908 }
909 
910 
911 #if EFSYS_OPT_SIENA
912 
913 #define	EFX_MAC_HASH_BITS	(1 << 8)
914 
915 /* Compute the multicast hash as used on Falcon and Siena. */
916 static	void
917 siena_mac_multicast_hash_compute(
918 	__in_ecount(6*count)		uint8_t const *addrs,
919 	__in				int count,
920 	__out				efx_oword_t *hash_low,
921 	__out				efx_oword_t *hash_high)
922 {
923 	uint32_t crc, index;
924 	int i;
925 
926 	EFSYS_ASSERT(hash_low != NULL);
927 	EFSYS_ASSERT(hash_high != NULL);
928 
929 	EFX_ZERO_OWORD(*hash_low);
930 	EFX_ZERO_OWORD(*hash_high);
931 
932 	for (i = 0; i < count; i++) {
933 		/* Calculate hash bucket (IEEE 802.3 CRC32 of the MAC addr) */
934 		crc = efx_crc32_calculate(0xffffffff, addrs, EFX_MAC_ADDR_LEN);
935 		index = crc % EFX_MAC_HASH_BITS;
936 		if (index < 128) {
937 			EFX_SET_OWORD_BIT(*hash_low, index);
938 		} else {
939 			EFX_SET_OWORD_BIT(*hash_high, index - 128);
940 		}
941 
942 		addrs += EFX_MAC_ADDR_LEN;
943 	}
944 }
945 
946 static	__checkReturn	efx_rc_t
947 siena_mac_multicast_list_set(
948 	__in		efx_nic_t *enp)
949 {
950 	efx_port_t *epp = &(enp->en_port);
951 	const efx_mac_ops_t *emop = epp->ep_emop;
952 	efx_oword_t old_hash[2];
953 	efx_rc_t rc;
954 
955 	EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
956 	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
957 
958 	memcpy(old_hash, epp->ep_multicst_hash, sizeof (old_hash));
959 
960 	siena_mac_multicast_hash_compute(
961 	    epp->ep_mulcst_addr_list,
962 	    epp->ep_mulcst_addr_count,
963 	    &epp->ep_multicst_hash[0],
964 	    &epp->ep_multicst_hash[1]);
965 
966 	if ((rc = emop->emo_reconfigure(enp)) != 0)
967 		goto fail1;
968 
969 	return (0);
970 
971 fail1:
972 	EFSYS_PROBE1(fail1, efx_rc_t, rc);
973 
974 	memcpy(epp->ep_multicst_hash, old_hash, sizeof (old_hash));
975 
976 	return (rc);
977 }
978 
979 #endif /* EFSYS_OPT_SIENA */
980