1 /*
2 * Copyright (c) 2008-2016 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/types.h>
32 #include <sys/ddi.h>
33 #include <sys/sunddi.h>
34 #include <sys/stream.h>
35 #include <sys/strsun.h>
36 #include <sys/strsubr.h>
37 #include <sys/dlpi.h>
38 #include <sys/ksynch.h>
39 #include <sys/cpuvar.h>
40 #include <sys/cpu.h>
41 #include <sys/vlan.h>
42
43 #include <inet/tcp.h>
44
45 #include "sfxge.h"
46
47 void
48 sfxge_gld_link_update(sfxge_t *sp)
49 {
50 sfxge_mac_t *smp = &(sp->s_mac);
51 link_state_t link;
52
53 switch (smp->sm_link_mode) {
54 case EFX_LINK_UNKNOWN:
55 link = LINK_STATE_UNKNOWN;
56 break;
57 case EFX_LINK_DOWN:
58 link = LINK_STATE_DOWN;
59 break;
60 default:
61 link = LINK_STATE_UP;
62 }
63
64 mac_link_update(sp->s_mh, link);
65 }
66
67 void
68 sfxge_gld_mtu_update(sfxge_t *sp)
69 {
70 #ifdef _USE_MTU_UPDATE
71 (void) mac_maxsdu_update(sp->s_mh, sp->s_mtu);
72 #else
73 _NOTE(ARGUNUSED(sp));
74 #endif
75 }
76
77 void
78 sfxge_gld_rx_post(sfxge_t *sp, unsigned int index, mblk_t *mp)
79 {
80 _NOTE(ARGUNUSED(index))
81
82 mac_rx(sp->s_mh, NULL, mp);
83 }
84
85
86 void
87 sfxge_gld_rx_push(sfxge_t *sp)
88 {
89 _NOTE(ARGUNUSED(sp))
90 }
91
92
93 static uint64_t
94 sfxge_phy_dfl_cap_test64(sfxge_t *sp, uint32_t field)
95 {
96 return (sfxge_phy_cap_test(sp, EFX_PHY_CAP_DEFAULT, field, NULL) ?
97 1ull : 0ull);
98 }
99
100
101 static uint64_t
102 sfxge_phy_cur_cap_test64(sfxge_t *sp, uint32_t field)
103 {
104 return (sfxge_phy_cap_test(sp, EFX_PHY_CAP_CURRENT, field, NULL) ?
105 1ull : 0ull);
106 }
107
108 static uint64_t
109 sfxge_phy_lp_cap_test64(sfxge_t *sp, uint32_t field)
110 {
111 return (sfxge_phy_lp_cap_test(sp, field) ? 1ull : 0ull);
112 }
113
114 static int
115 sfxge_gld_getstat(void *arg, unsigned int id, uint64_t *valp)
116 {
117 sfxge_t *sp = arg;
118 efx_nic_t *enp = sp->s_enp;
119 int rc;
120
121 if (sp->s_mac.sm_state != SFXGE_MAC_STARTED) {
122 rc = ENODEV;
123 goto fail1;
124 }
125
126 switch (id) {
127 case MAC_STAT_IFSPEED: {
128 unsigned int speed;
129
130 sfxge_mac_link_speed_get(sp, &speed);
131
132 *valp = (uint64_t)speed * 1000000ull;
133 break;
134 }
135 case ETHER_STAT_LINK_DUPLEX: {
136 sfxge_link_duplex_t duplex;
137
138 sfxge_mac_link_duplex_get(sp, &duplex);
139
140 switch (duplex) {
141 case SFXGE_LINK_DUPLEX_UNKNOWN:
142 *valp = LINK_DUPLEX_UNKNOWN;
143 break;
144
145 case SFXGE_LINK_DUPLEX_HALF:
146 *valp = LINK_DUPLEX_HALF;
147 break;
148
149 case SFXGE_LINK_DUPLEX_FULL:
150 *valp = LINK_DUPLEX_FULL;
151 break;
152
153 default:
154 ASSERT(B_FALSE);
155 break;
156 }
157 break;
158 }
159
160 case ETHER_STAT_CAP_40GFDX:
161 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_40000FDX);
162 break;
163 case ETHER_STAT_CAP_10GFDX:
164 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10000FDX);
165 break;
166 case ETHER_STAT_CAP_1000FDX:
167 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_1000FDX);
168 break;
169 case ETHER_STAT_CAP_1000HDX:
170 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_1000HDX);
171 break;
172 case ETHER_STAT_CAP_100FDX:
173 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_100FDX);
174 break;
175 case ETHER_STAT_CAP_100HDX:
176 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_100HDX);
177 break;
178 case ETHER_STAT_CAP_10FDX:
179 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10FDX);
180 break;
181 case ETHER_STAT_CAP_10HDX:
182 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10HDX);
183 break;
184 case ETHER_STAT_CAP_ASMPAUSE:
185 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_ASYM);
186 break;
187 case ETHER_STAT_CAP_PAUSE:
188 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_PAUSE);
189 break;
190 case ETHER_STAT_CAP_AUTONEG:
191 *valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_AN);
192 break;
193 case ETHER_STAT_ADV_CAP_40GFDX:
194 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_40000FDX);
195 break;
196 case ETHER_STAT_ADV_CAP_10GFDX:
197 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10000FDX);
198 break;
199 case ETHER_STAT_ADV_CAP_1000FDX:
200 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_1000FDX);
201 break;
202 case ETHER_STAT_ADV_CAP_1000HDX:
203 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_1000HDX);
204 break;
205 case ETHER_STAT_ADV_CAP_100FDX:
206 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_100FDX);
207 break;
208 case ETHER_STAT_ADV_CAP_100HDX:
209 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_100HDX);
210 break;
211 case ETHER_STAT_ADV_CAP_10FDX:
212 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10FDX);
213 break;
214 case ETHER_STAT_ADV_CAP_10HDX:
215 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10HDX);
216 break;
217 case ETHER_STAT_ADV_CAP_ASMPAUSE:
218 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_ASYM);
219 break;
220 case ETHER_STAT_ADV_CAP_PAUSE:
221 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_PAUSE);
222 break;
223 case ETHER_STAT_ADV_CAP_AUTONEG:
224 *valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_AN);
225 break;
226 case ETHER_STAT_LP_CAP_40GFDX:
227 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_40000FDX);
228 break;
229 case ETHER_STAT_LP_CAP_10GFDX:
230 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10000FDX);
231 break;
232 case ETHER_STAT_LP_CAP_1000FDX:
233 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_1000FDX);
234 break;
235 case ETHER_STAT_LP_CAP_1000HDX:
236 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_1000HDX);
237 break;
238 case ETHER_STAT_LP_CAP_100FDX:
239 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_100FDX);
240 break;
241 case ETHER_STAT_LP_CAP_100HDX:
242 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_100HDX);
243 break;
244 case ETHER_STAT_LP_CAP_10FDX:
245 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10FDX);
246 break;
247 case ETHER_STAT_LP_CAP_10HDX:
248 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10HDX);
249 break;
250 case ETHER_STAT_LP_CAP_ASMPAUSE:
251 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_ASYM);
252 break;
253 case ETHER_STAT_LP_CAP_PAUSE:
254 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_PAUSE);
255 break;
256 case ETHER_STAT_LP_CAP_AUTONEG:
257 *valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_AN);
258 break;
259
260 case ETHER_STAT_XCVR_ADDR: {
261 const efx_nic_cfg_t *encp = efx_nic_cfg_get(enp);
262 *valp = encp->enc_port;
263 break;
264 }
265 case ETHER_STAT_XCVR_ID: {
266 uint32_t oui;
267
268 if ((rc = efx_phy_oui_get(sp->s_enp, &oui)) != 0)
269 goto fail2;
270 *valp = oui;
271 break;
272 }
273 case MAC_STAT_MULTIRCV:
274 sfxge_mac_stat_get(sp, EFX_MAC_RX_MULTICST_PKTS, valp);
275 break;
276
277 case MAC_STAT_BRDCSTRCV:
278 sfxge_mac_stat_get(sp, EFX_MAC_RX_BRDCST_PKTS, valp);
279 break;
280
281 case MAC_STAT_MULTIXMT:
282 sfxge_mac_stat_get(sp, EFX_MAC_TX_MULTICST_PKTS, valp);
283 break;
284
285 case MAC_STAT_BRDCSTXMT:
286 sfxge_mac_stat_get(sp, EFX_MAC_TX_BRDCST_PKTS, valp);
287 break;
288
289 case MAC_STAT_IERRORS:
290 sfxge_mac_stat_get(sp, EFX_MAC_RX_ERRORS, valp);
291 break;
292
293 case MAC_STAT_OERRORS:
294 sfxge_mac_stat_get(sp, EFX_MAC_TX_ERRORS, valp);
295 break;
296
297 case MAC_STAT_RBYTES:
298 sfxge_mac_stat_get(sp, EFX_MAC_RX_OCTETS, valp);
299 break;
300
301 case MAC_STAT_IPACKETS:
302 sfxge_mac_stat_get(sp, EFX_MAC_RX_PKTS, valp);
303 break;
304
305 case MAC_STAT_OBYTES:
306 sfxge_mac_stat_get(sp, EFX_MAC_TX_OCTETS, valp);
307 break;
308
309 case MAC_STAT_OPACKETS:
310 sfxge_mac_stat_get(sp, EFX_MAC_TX_PKTS, valp);
311 break;
312
313 case MAC_STAT_NORCVBUF:
314 sfxge_mac_stat_get(sp, EFX_MAC_RX_DROP_EVENTS, valp);
315 break;
316
317 case ETHER_STAT_FCS_ERRORS:
318 sfxge_mac_stat_get(sp, EFX_MAC_RX_FCS_ERRORS, valp);
319 break;
320
321 default:
322 rc = ENOTSUP;
323 goto fail3;
324 }
325
326 return (0);
327 fail3:
328 DTRACE_PROBE(fail3);
329 fail2:
330 DTRACE_PROBE(fail2);
331 fail1:
332 DTRACE_PROBE1(fail1, int, rc);
333
334 return (rc);
335 }
336
337 static int
338 sfxge_gld_start(void *arg)
339 {
340 sfxge_t *sp = arg;
341 int rc;
342
343 if ((rc = sfxge_start(sp, B_FALSE)) != 0)
344 goto fail1;
345
346 return (0);
347
348 fail1:
349 DTRACE_PROBE1(fail1, int, rc);
350
351 return (rc);
352 }
353
354 static void
355 sfxge_gld_stop(void *arg)
356 {
357 sfxge_t *sp = arg;
358
359 sfxge_stop(sp);
360 }
361
362 static int
363 sfxge_gld_setpromisc(void *arg, boolean_t on)
364 {
365 sfxge_t *sp = arg;
366
367 return sfxge_mac_promisc_set(sp,
368 (on) ? SFXGE_PROMISC_ALL_PHYS : SFXGE_PROMISC_OFF);
369 }
370
371 static int
372 sfxge_gld_multicst(void *arg, boolean_t add, const uint8_t *addr)
373 {
374 sfxge_t *sp = arg;
375 int rc;
376
377 if (add) {
378 if ((rc = sfxge_mac_multicst_add(sp, addr)) != 0)
379 goto fail1;
380 } else {
381 if ((rc = sfxge_mac_multicst_remove(sp, addr)) != 0)
382 goto fail2;
383 }
384
385 return (0);
386
387 fail2:
388 DTRACE_PROBE(fail2);
389 fail1:
390 DTRACE_PROBE1(fail1, int, rc);
391 return (rc);
392 }
393
394 static int
395 sfxge_gld_unicst(void *arg, const uint8_t *addr)
396 {
397 sfxge_t *sp = arg;
398 int rc;
399
400 if ((rc = sfxge_mac_unicst_set(sp, (uint8_t *)addr)) != 0)
401 goto fail1;
402
403 return (0);
404
405 fail1:
406 DTRACE_PROBE1(fail1, int, rc);
407
408 return (rc);
409 }
410
411 static void
412 sfxge_gld_ioctl(void *arg, queue_t *wq, mblk_t *mp)
413 {
414 sfxge_t *sp = arg;
415
416 sfxge_ioctl(sp, wq, mp);
417 }
418
419
420 static mblk_t *
421 sfxge_gld_tx(void *arg, mblk_t *mp)
422 {
423 sfxge_t *sp = arg;
424 mblk_t *next;
425
426 /* Walk the packet chain */
427 do {
428 /* Break the packet out of the chain */
429 next = mp->b_next;
430 mp->b_next = NULL;
431
432 if (next != NULL)
433 prefetch_read_many(next);
434
435 /* Post the packet in the appropriate transmit queue */
436 if (sfxge_tx_packet_add(sp, mp) == ENOSPC) {
437 mp->b_next = next;
438 return (mp);
439 }
440
441 mp = next;
442 } while (mp != NULL);
443
444 return (NULL);
445 }
446
447 /*
448 * This must not be static, in order to be tunable by /etc/system.
449 * (Static declarations may be optmized away by the compiler.)
450 */
451 boolean_t sfxge_lso = B_TRUE;
452
453 static boolean_t
454 sfxge_gld_getcapab(void *arg, mac_capab_t cap, void *cap_arg)
455 {
456 int rc;
457
458 _NOTE(ARGUNUSED(arg))
459
460 switch (cap) {
461 case MAC_CAPAB_LSO: {
462 mac_capab_lso_t *lsop = cap_arg;
463
464 /* Check whether LSO is disabled */
465 if (!sfxge_lso) {
466 rc = ENOTSUP;
467 goto fail1;
468 }
469
470 DTRACE_PROBE(lso);
471
472 lsop->lso_flags = LSO_TX_BASIC_TCP_IPV4;
473 lsop->lso_basic_tcp_ipv4.lso_max = TCP_MAX_LSO_LENGTH;
474 break;
475 }
476 case MAC_CAPAB_HCKSUM: {
477 uint32_t *hcksump = cap_arg;
478
479 DTRACE_PROBE(cksum);
480
481 *hcksump = HCKSUM_INET_FULL_V4 | HCKSUM_IPHDRCKSUM;
482 break;
483 }
484 default:
485 rc = ENOTSUP;
486 goto fail1;
487 }
488
489 return (B_TRUE);
490
491 fail1:
492 DTRACE_PROBE1(fail1, int, rc);
493
494 return (B_FALSE);
495 }
496
497 /*
498 * GLDv3 driver-private property names must be preceded by an underscore - see
499 * mc_getprop(9E).
500 */
501 #define SFXGE_PRIV_PROP_NAME(s) ("_" #s)
502
503 #define SFXGE_XSTR(s) SFXGE_STR(s)
504 #define SFXGE_STR(s) #s
505
506 static void
507 sfxge_gld_priv_prop_info(sfxge_t *sp, const char *name,
508 mac_prop_info_handle_t handle)
509 {
510 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
511 mac_prop_info_set_default_uint32(handle,
512 SFXGE_RX_COALESCE_OFF);
513 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
514 return;
515 }
516
517 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
518 mac_prop_info_set_default_uint32(handle, ncpus);
519 mac_prop_info_set_range_uint32(handle, 1,
520 (uint32_t)sp->s_intr.si_nalloc);
521 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
522 return;
523 }
524
525 if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
526 mac_prop_info_set_default_uint32(handle,
527 SFXGE_DEFAULT_MODERATION);
528 mac_prop_info_set_range_uint32(handle,
529 0, efx_nic_cfg_get(sp->s_enp)->enc_evq_timer_max_us);
530 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
531 return;
532 }
533
534 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
535 mac_prop_info_set_default_uint8(handle, 0);
536 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
537 return;
538 }
539
540 #if EFSYS_OPT_MCDI_LOGGING
541 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
542 mac_prop_info_set_default_uint8(handle, 0);
543 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
544 return;
545 }
546 #endif
547 DTRACE_PROBE(unknown_priv_prop);
548 }
549
550
551 static int
552 sfxge_gld_priv_prop_get(sfxge_t *sp, const char *name,
553 unsigned int size, void *valp)
554 {
555 long val;
556 int rc;
557
558 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
559 sfxge_rx_coalesce_mode_t mode;
560
561 sfxge_rx_coalesce_mode_get(sp, &mode);
562
563 val = (long)mode;
564 goto done;
565 }
566
567 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
568 unsigned int count;
569
570 if (sfxge_rx_scale_count_get(sp, &count) != 0)
571 count = 0;
572
573 val = (long)count;
574 goto done;
575 }
576
577 if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
578 unsigned int us;
579
580 sfxge_ev_moderation_get(sp, &us);
581
582 val = (long)us;
583 goto done;
584 }
585
586 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
587 val = (long)sp->s_mon.sm_polling;
588 goto done;
589 }
590
591 #if EFSYS_OPT_MCDI_LOGGING
592 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
593 val = (long)sp->s_mcdi_logging;
594 goto done;
595 }
596 #endif
597
598 rc = ENOTSUP;
599 goto fail1;
600
601 done:
602 (void) snprintf(valp, size, "%ld", val);
603
604 return (0);
605
606 fail1:
607 DTRACE_PROBE1(fail1, int, rc);
608
609 return (rc);
610 }
611
612
613 static int
614 sfxge_gld_priv_prop_set(sfxge_t *sp, const char *name, unsigned int size,
615 const void *valp)
616 {
617 long val;
618 int rc = 0;
619
620 _NOTE(ARGUNUSED(size))
621
622 (void) ddi_strtol(valp, (char **)NULL, 0, &val);
623
624 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
625 if ((rc = sfxge_rx_coalesce_mode_set(sp,
626 (sfxge_rx_coalesce_mode_t)val)) != 0)
627 goto fail1;
628
629 goto done;
630 }
631
632 if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
633 if ((rc = sfxge_rx_scale_count_set(sp, (unsigned int)val)) != 0)
634 goto fail1;
635
636 goto done;
637 }
638
639 if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
640 if ((rc = sfxge_ev_moderation_set(sp, (unsigned int) val)) != 0)
641 goto fail1;
642
643 goto done;
644 }
645
646 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
647 sp->s_mon.sm_polling = (int)val;
648 goto done;
649 }
650
651 #if EFSYS_OPT_MCDI_LOGGING
652 if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
653 sp->s_mcdi_logging = (int)val;
654 goto done;
655 }
656 #endif
657
658
659 rc = ENOTSUP;
660 goto fail1;
661
662 done:
663 return (0);
664
665 fail1:
666 DTRACE_PROBE1(fail1, int, rc);
667
668 return (rc);
669 }
670
671
672 #if EFSYS_OPT_MCDI_LOGGING
673 #define SFXGE_N_NAMED_PROPS 4
674 #else
675 #define SFXGE_N_NAMED_PROPS 3
676 #endif
677
678 static void
679 sfxge_gld_priv_prop_init(sfxge_t *sp)
680 {
681 sfxge_mac_priv_prop_t *mac_priv_props;
682 unsigned int nprops = 0;
683
684 /*
685 * We have named_props (3 or 4) named properties and the structure must
686 * be finished by a NULL pointer.
687 */
688 sp->s_mac_priv_props_alloc = SFXGE_N_NAMED_PROPS + 1;
689 sp->s_mac_priv_props = kmem_zalloc(sizeof (sfxge_mac_priv_prop_t) *
690 sp->s_mac_priv_props_alloc,
691 KM_SLEEP);
692
693 /*
694 * Driver-private property names start with an underscore - see
695 * mc_getprop(9E).
696 */
697
698 mac_priv_props = sp->s_mac_priv_props;
699
700 *mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
701 (void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
702 SFXGE_PRIV_PROP_NAME(rx_coalesce_mode));
703 mac_priv_props++;
704 nprops++;
705
706 *mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
707 (void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
708 SFXGE_PRIV_PROP_NAME(rx_scale_count));
709 mac_priv_props++;
710 nprops++;
711
712 *mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
713 (void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
714 SFXGE_PRIV_PROP_NAME(intr_moderation));
715 mac_priv_props++;
716 nprops++;
717
718 #if EFSYS_OPT_MCDI_LOGGING
719 *mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
720 (void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
721 SFXGE_PRIV_PROP_NAME(mcdi_logging));
722 mac_priv_props++;
723 nprops++;
724 #endif
725
726 ASSERT3U((nprops + 1), ==, sp->s_mac_priv_props_alloc);
727
728 /* Terminated by a NULL pointer */
729 *mac_priv_props = NULL;
730 }
731
732 static void
733 sfxge_gld_priv_prop_fini(sfxge_t *sp)
734 {
735 char **mac_priv_props;
736 unsigned int id;
737
738 mac_priv_props = sp->s_mac_priv_props;
739
740 for (id = 0; id < SFXGE_N_NAMED_PROPS; id++) {
741 kmem_free(*mac_priv_props, MAXLINKPROPNAME);
742 mac_priv_props++;
743 }
744
745 kmem_free(sp->s_mac_priv_props, sizeof (sfxge_mac_priv_prop_t) *
746 sp->s_mac_priv_props_alloc);
747 sp->s_mac_priv_props = NULL;
748 }
749
750
751 static int
752 sfxge_gld_getprop(void *arg, const char *name, mac_prop_id_t id,
753 unsigned int size, void *valp)
754 {
755 sfxge_t *sp = arg;
756 uint32_t flag = EFX_PHY_CAP_CURRENT;
757 uint8_t *v8 = ((uint8_t *)valp);
758 int rc;
759
760 /* check size */
761 switch (id) {
762 case MAC_PROP_DUPLEX:
763 if (size < sizeof (link_duplex_t)) {
764 rc = EINVAL;
765 goto fail1;
766 }
767 break;
768 case MAC_PROP_FLOWCTRL:
769 if (size < sizeof (link_flowctrl_t)) {
770 rc = EINVAL;
771 goto fail1;
772 }
773 break;
774 case MAC_PROP_SPEED:
775 case MAC_PROP_STATUS:
776 if (size < sizeof (uint64_t)) {
777 rc = EINVAL;
778 goto fail1;
779 }
780 break;
781 case MAC_PROP_MTU:
782 if (size < sizeof (uint32_t)) {
783 rc = EINVAL;
784 goto fail1;
785 }
786 break;
787 case MAC_PROP_EN_AUTONEG:
788 case MAC_PROP_AUTONEG:
789 case MAC_PROP_EN_40GFDX_CAP:
790 case MAC_PROP_ADV_40GFDX_CAP:
791 case MAC_PROP_EN_10GFDX_CAP:
792 case MAC_PROP_ADV_10GFDX_CAP:
793 case MAC_PROP_EN_1000FDX_CAP:
794 case MAC_PROP_ADV_1000FDX_CAP:
795 case MAC_PROP_EN_1000HDX_CAP:
796 case MAC_PROP_ADV_1000HDX_CAP:
797 case MAC_PROP_EN_100FDX_CAP:
798 case MAC_PROP_ADV_100FDX_CAP:
799 case MAC_PROP_EN_100HDX_CAP:
800 case MAC_PROP_ADV_100HDX_CAP:
801 case MAC_PROP_EN_10FDX_CAP:
802 case MAC_PROP_ADV_10FDX_CAP:
803 case MAC_PROP_EN_10HDX_CAP:
804 case MAC_PROP_ADV_10HDX_CAP:
805 if (size < sizeof (uint8_t)) {
806 rc = EINVAL;
807 goto fail1;
808 }
809 break;
810 case MAC_PROP_PRIVATE:
811 /* sfxge_gld_priv_prop_get should do any size checking */
812 break;
813 default:
814 rc = ENOTSUP;
815 goto fail1;
816 }
817
818 switch (id) {
819 case MAC_PROP_DUPLEX: {
820 sfxge_link_duplex_t duplex;
821
822 sfxge_mac_link_duplex_get(sp, &duplex);
823
824 switch (duplex) {
825 case SFXGE_LINK_DUPLEX_UNKNOWN:
826 *((link_duplex_t *)valp) = LINK_DUPLEX_UNKNOWN;
827 break;
828
829 case SFXGE_LINK_DUPLEX_HALF:
830 *((link_duplex_t *)valp) = LINK_DUPLEX_HALF;
831 break;
832
833 case SFXGE_LINK_DUPLEX_FULL:
834 *((link_duplex_t *)valp) = LINK_DUPLEX_FULL;
835 break;
836
837 default:
838 ASSERT(B_FALSE);
839 break;
840 }
841
842 break;
843 }
844 case MAC_PROP_SPEED: {
845 unsigned int speed;
846
847 sfxge_mac_link_speed_get(sp, &speed);
848
849 *((uint64_t *)valp) = (uint64_t)speed * 1000000ull;
850
851 break;
852 }
853 case MAC_PROP_STATUS: {
854 boolean_t up;
855
856 sfxge_mac_link_check(sp, &up);
857
858 *((link_state_t *)valp) = (up) ?
859 LINK_STATE_UP : LINK_STATE_DOWN;
860
861 break;
862 }
863 case MAC_PROP_EN_AUTONEG:
864 case MAC_PROP_AUTONEG:
865 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_AN, NULL);
866 break;
867 case MAC_PROP_EN_40GFDX_CAP:
868 case MAC_PROP_ADV_40GFDX_CAP:
869 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_40000FDX, NULL);
870 break;
871 case MAC_PROP_EN_10GFDX_CAP:
872 case MAC_PROP_ADV_10GFDX_CAP:
873 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10000FDX, NULL);
874 break;
875 case MAC_PROP_EN_1000FDX_CAP:
876 case MAC_PROP_ADV_1000FDX_CAP:
877 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_1000FDX, NULL);
878 break;
879 case MAC_PROP_EN_1000HDX_CAP:
880 case MAC_PROP_ADV_1000HDX_CAP:
881 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_1000HDX, NULL);
882 break;
883 case MAC_PROP_EN_100FDX_CAP:
884 case MAC_PROP_ADV_100FDX_CAP:
885 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_100FDX, NULL);
886 break;
887 case MAC_PROP_EN_100HDX_CAP:
888 case MAC_PROP_ADV_100HDX_CAP:
889 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_100HDX, NULL);
890 break;
891 case MAC_PROP_EN_10FDX_CAP:
892 case MAC_PROP_ADV_10FDX_CAP:
893 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10FDX, NULL);
894 break;
895 case MAC_PROP_EN_10HDX_CAP:
896 case MAC_PROP_ADV_10HDX_CAP:
897 *v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10HDX, NULL);
898 break;
899 case MAC_PROP_MTU:
900 *((uint32_t *)valp) = (uint32_t)(sp->s_mtu);
901 break;
902
903 case MAC_PROP_FLOWCTRL: {
904 unsigned int fcntl;
905
906 sfxge_mac_fcntl_get(sp, &fcntl);
907
908 switch (fcntl) {
909 case 0:
910 *((link_flowctrl_t *)valp) = LINK_FLOWCTRL_NONE;
911 break;
912
913 case EFX_FCNTL_GENERATE:
914 *((link_flowctrl_t *)valp) = LINK_FLOWCTRL_RX;
915 break;
916
917 case EFX_FCNTL_RESPOND:
918 *((link_flowctrl_t *)valp) = LINK_FLOWCTRL_TX;
919 break;
920
921 case (EFX_FCNTL_GENERATE | EFX_FCNTL_RESPOND):
922 *((link_flowctrl_t *)valp) = LINK_FLOWCTRL_BI;
923 break;
924
925 default:
926 ASSERT(B_FALSE);
927 break;
928 }
929 break;
930 }
931 case MAC_PROP_PRIVATE:
932 if ((rc = sfxge_gld_priv_prop_get(sp, name, size, valp)) != 0)
933 goto fail2;
934 break;
935 default:
936 rc = ENOTSUP;
937 goto fail3;
938 }
939
940 return (0);
941
942 fail3:
943 DTRACE_PROBE(fail3);
944
945 fail2:
946 DTRACE_PROBE(fail2);
947
948 fail1:
949 DTRACE_PROBE1(fail1, int, rc);
950
951 return (rc);
952 }
953
954
955 static int
956 sfxge_gld_setprop(void *arg, const char *name, mac_prop_id_t id,
957 unsigned int size, const void *valp)
958 {
959 sfxge_t *sp = arg;
960 int v8 = *(uint8_t *)valp;
961 int rc;
962
963 /* get size checks out fo the way */
964 switch (id) {
965 /*
966 * On Sol11 (no updates) dladm seems to be using MAC_PROP_AUTONEG to set
967 * the autoneg parameter. This does not match the scheme suggested in
968 * mac(9E) but as they both map to the same think in the driver and in
969 * dladm it doesn't matter.
970 */
971 case MAC_PROP_AUTONEG:
972 case MAC_PROP_EN_AUTONEG:
973 case MAC_PROP_EN_40GFDX_CAP:
974 case MAC_PROP_EN_10GFDX_CAP:
975 case MAC_PROP_EN_1000FDX_CAP:
976 case MAC_PROP_EN_1000HDX_CAP:
977 case MAC_PROP_EN_100FDX_CAP:
978 case MAC_PROP_EN_100HDX_CAP:
979 case MAC_PROP_EN_10FDX_CAP:
980 case MAC_PROP_EN_10HDX_CAP:
981 if (size < sizeof (uint8_t)) {
982 rc = EINVAL;
983 goto fail1;
984 }
985 break;
986 case MAC_PROP_MTU:
987 if (size < sizeof (uint32_t)) {
988 rc = EINVAL;
989 goto fail1;
990 }
991 break;
992 case MAC_PROP_FLOWCTRL:
993 if (size < sizeof (link_flowctrl_t)) {
994 rc = EINVAL;
995 goto fail1;
996 }
997 break;
998 case MAC_PROP_PRIVATE:
999 /* sfxge_gld_priv_prop_set should do any size checking */
1000 break;
1001 default:
1002 rc = ENOTSUP;
1003 goto fail1;
1004 }
1005
1006 switch (id) {
1007 /*
1008 * It is unclear which of MAC_PROP_AUTONEG and MAC_PROP_EN_AUTONEG is
1009 * used. Try both.
1010 */
1011 case MAC_PROP_AUTONEG:
1012 case MAC_PROP_EN_AUTONEG:
1013 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_AN, v8)) != 0)
1014 goto fail2;
1015 break;
1016 case MAC_PROP_EN_40GFDX_CAP:
1017 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_40000FDX, v8)) != 0)
1018 goto fail2;
1019 break;
1020 case MAC_PROP_EN_10GFDX_CAP: {
1021 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10000FDX, v8)) != 0)
1022 goto fail2;
1023 break;
1024 }
1025 case MAC_PROP_EN_1000FDX_CAP: {
1026 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_1000FDX, v8)) != 0)
1027 goto fail2;
1028 break;
1029 }
1030 case MAC_PROP_EN_1000HDX_CAP: {
1031 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_1000HDX, v8)) != 0)
1032 goto fail2;
1033 break;
1034 }
1035 case MAC_PROP_EN_100FDX_CAP: {
1036 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_100FDX, v8)) != 0)
1037 goto fail2;
1038 break;
1039 }
1040 case MAC_PROP_EN_100HDX_CAP: {
1041 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_100HDX, v8)) != 0)
1042 goto fail2;
1043 break;
1044 }
1045 case MAC_PROP_EN_10FDX_CAP: {
1046 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10FDX, v8)) != 0)
1047 goto fail2;
1048 break;
1049 }
1050 case MAC_PROP_EN_10HDX_CAP: {
1051 if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10HDX, v8)) != 0)
1052 goto fail2;
1053 break;
1054 }
1055 case MAC_PROP_MTU: {
1056 size_t mtu = (size_t)(*((uint32_t *)valp));
1057
1058 if (mtu > EFX_MAC_SDU_MAX) {
1059 rc = EINVAL;
1060 goto fail2;
1061 }
1062
1063 sp->s_mtu = mtu;
1064
1065 DTRACE_PROBE(restart_mtu);
1066 (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_OK,
1067 "MTU changing", (uint32_t)mtu);
1068
1069 break;
1070 }
1071 case MAC_PROP_FLOWCTRL: {
1072 unsigned int fcntl = 0;
1073
1074 switch (*((link_flowctrl_t *)valp)) {
1075 case LINK_FLOWCTRL_NONE:
1076 fcntl = 0;
1077 break;
1078
1079 case LINK_FLOWCTRL_RX:
1080 fcntl = EFX_FCNTL_GENERATE;
1081 break;
1082
1083 case LINK_FLOWCTRL_TX:
1084 fcntl = EFX_FCNTL_RESPOND;
1085 break;
1086
1087 case LINK_FLOWCTRL_BI:
1088 fcntl = EFX_FCNTL_GENERATE | EFX_FCNTL_RESPOND;
1089 break;
1090
1091 default:
1092 rc = EINVAL;
1093 goto fail2;
1094 }
1095
1096 if ((rc = sfxge_mac_fcntl_set(sp, fcntl)) != 0)
1097 goto fail3;
1098
1099 break;
1100 }
1101 case MAC_PROP_PRIVATE:
1102 if ((rc = sfxge_gld_priv_prop_set(sp, name, size, valp)) != 0)
1103 goto fail4;
1104
1105 break;
1106 default:
1107 rc = ENOTSUP;
1108 goto fail5;
1109 }
1110
1111 return (0);
1112
1113 fail5:
1114 DTRACE_PROBE(fail5);
1115
1116 fail4:
1117 DTRACE_PROBE(fail4);
1118
1119 fail3:
1120 DTRACE_PROBE(fail3);
1121
1122 fail2:
1123 DTRACE_PROBE(fail2);
1124
1125 fail1:
1126 DTRACE_PROBE1(fail1, int, rc);
1127
1128 return (rc);
1129 }
1130
1131 static void
1132 sfxge_gld_propinfo(void *arg, const char *name, mac_prop_id_t id,
1133 mac_prop_info_handle_t handle)
1134 {
1135 sfxge_t *sp = arg;
1136 efx_phy_cap_type_t phy_cap = EFX_PHY_CAP_INVALID;
1137 switch (id) {
1138 case MAC_PROP_DUPLEX:
1139 mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
1140 return;
1141 case MAC_PROP_FLOWCTRL:
1142 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
1143 mac_prop_info_set_default_link_flowctrl(handle,
1144 LINK_FLOWCTRL_BI);
1145 return;
1146 case MAC_PROP_SPEED:
1147 mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
1148 return;
1149 case MAC_PROP_STATUS:
1150 mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
1151 return;
1152 case MAC_PROP_MTU: {
1153 uint32_t mtu_default;
1154 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
1155 mtu_default = ddi_prop_get_int(DDI_DEV_T_ANY,
1156 sp->s_dip, DDI_PROP_DONTPASS, "mtu", ETHERMTU);
1157 mac_prop_info_set_default_uint32(handle, mtu_default);
1158 return;
1159 }
1160 case MAC_PROP_PRIVATE:
1161 sfxge_gld_priv_prop_info(sp, name, handle);
1162 return;
1163 case MAC_PROP_EN_AUTONEG:
1164 case MAC_PROP_AUTONEG:
1165 phy_cap = EFX_PHY_CAP_AN;
1166 break;
1167 case MAC_PROP_EN_10GFDX_CAP:
1168 case MAC_PROP_ADV_10GFDX_CAP:
1169 phy_cap = EFX_PHY_CAP_10000FDX;
1170 break;
1171 case MAC_PROP_EN_1000FDX_CAP:
1172 case MAC_PROP_ADV_1000FDX_CAP:
1173 phy_cap = EFX_PHY_CAP_1000FDX;
1174 break;
1175 case MAC_PROP_EN_1000HDX_CAP:
1176 case MAC_PROP_ADV_1000HDX_CAP:
1177 phy_cap = EFX_PHY_CAP_1000HDX;
1178 break;
1179 case MAC_PROP_EN_100FDX_CAP:
1180 case MAC_PROP_ADV_100FDX_CAP:
1181 phy_cap = EFX_PHY_CAP_100FDX;
1182 break;
1183 case MAC_PROP_EN_100HDX_CAP:
1184 case MAC_PROP_ADV_100HDX_CAP:
1185 phy_cap = EFX_PHY_CAP_100HDX;
1186 break;
1187 case MAC_PROP_EN_10FDX_CAP:
1188 case MAC_PROP_ADV_10FDX_CAP:
1189 phy_cap = EFX_PHY_CAP_10FDX;
1190 break;
1191 case MAC_PROP_EN_10HDX_CAP:
1192 case MAC_PROP_ADV_10HDX_CAP:
1193 phy_cap = EFX_PHY_CAP_10HDX;
1194 break;
1195 default:
1196 DTRACE_PROBE(unknown_prop);
1197 return;
1198 }
1199 if (phy_cap != EFX_PHY_CAP_INVALID) {
1200 boolean_t rw;
1201 uint8_t cap_default;
1202 cap_default = sfxge_phy_cap_test(sp, EFX_PHY_CAP_DEFAULT,
1203 phy_cap, &rw);
1204 if (rw == B_TRUE)
1205 mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
1206 else
1207 mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
1208 mac_prop_info_set_default_uint8(handle, cap_default);
1209 }
1210 }
1211
1212 int
1213 sfxge_gld_register(sfxge_t *sp)
1214 {
1215 mac_callbacks_t *mcp;
1216 mac_register_t *mrp;
1217 mac_handle_t mh;
1218 uint8_t addr[ETHERADDRL];
1219 int rc;
1220
1221 if ((mrp = mac_alloc(MAC_VERSION)) == NULL) {
1222 rc = ENOTSUP;
1223 goto fail1;
1224 }
1225
1226 mrp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1227 mrp->m_driver = sp;
1228 mrp->m_dip = sp->s_dip;
1229
1230 /* Set up the callbacks */
1231 mcp = &(sp->s_mc);
1232 bzero(mcp, sizeof (mac_callbacks_t));
1233
1234 mcp->mc_getstat = sfxge_gld_getstat;
1235 mcp->mc_start = sfxge_gld_start;
1236 mcp->mc_stop = sfxge_gld_stop;
1237 mcp->mc_setpromisc = sfxge_gld_setpromisc;
1238 mcp->mc_multicst = sfxge_gld_multicst;
1239 mcp->mc_unicst = sfxge_gld_unicst;
1240 mcp->mc_tx = sfxge_gld_tx;
1241
1242 mcp->mc_callbacks |= MC_IOCTL;
1243 mcp->mc_ioctl = sfxge_gld_ioctl;
1244
1245 mcp->mc_callbacks |= MC_GETCAPAB;
1246 mcp->mc_getcapab = sfxge_gld_getcapab;
1247
1248 mcp->mc_callbacks |= MC_SETPROP;
1249 mcp->mc_setprop = sfxge_gld_setprop;
1250
1251 mcp->mc_callbacks |= MC_GETPROP;
1252 mcp->mc_getprop = sfxge_gld_getprop;
1253
1254 mcp->mc_callbacks |= MC_PROPINFO;
1255 mcp->mc_propinfo = sfxge_gld_propinfo;
1256
1257 mrp->m_callbacks = mcp;
1258
1259 mrp->m_src_addr = addr;
1260
1261 if ((rc = sfxge_mac_unicst_get(sp, SFXGE_UNICST_BIA,
1262 mrp->m_src_addr)) != 0)
1263 goto fail2;
1264
1265 mrp->m_min_sdu = 0;
1266 mrp->m_max_sdu = sp->s_mtu;
1267
1268 mrp->m_margin = VLAN_TAGSZ;
1269
1270 /* Set up the private properties */
1271 /* NOTE: m_priv_props added in s10u9 */
1272 mrp->m_priv_props = sp->s_mac_priv_props;
1273 sfxge_gld_priv_prop_init(sp);
1274
1275 /* NOTE: m_flags added in s11.0 */
1276 /* NOTE: m_multicast_sdu added in s11.0 */
1277
1278 /* Register the interface */
1279 if ((rc = mac_register(mrp, &mh)) != 0)
1280 goto fail3;
1281
1282 /* Free the stack registration object */
1283 kmem_free(mrp, sizeof (mac_register_t));
1284
1285 sp->s_mh = mh;
1286
1287 return (0);
1288 fail3:
1289 DTRACE_PROBE(fail3);
1290 fail2:
1291 DTRACE_PROBE(fail2);
1292
1293 /* Free the stack registration object */
1294 mac_free(mrp);
1295
1296 /* Tear down the private properties */
1297 sfxge_gld_priv_prop_fini(sp);
1298
1299 /* Clear the callbacks */
1300 bzero(&(sp->s_mc), sizeof (mac_callbacks_t));
1301
1302 fail1:
1303 DTRACE_PROBE1(fail1, int, rc);
1304
1305 return (rc);
1306 }
1307
1308 int
1309 sfxge_gld_unregister(sfxge_t *sp)
1310 {
1311 mac_handle_t mh = sp->s_mh;
1312 int rc;
1313
1314 if ((rc = mac_unregister(mh)) != 0)
1315 goto fail1;
1316
1317 sp->s_mh = NULL;
1318
1319 /* Tear down the private properties */
1320 sfxge_gld_priv_prop_fini(sp);
1321
1322 /* Clear the callbacks */
1323 bzero(&(sp->s_mc), sizeof (mac_callbacks_t));
1324
1325 return (0);
1326
1327 fail1:
1328 DTRACE_PROBE1(fail1, int, rc);
1329
1330 return (rc);
1331 }