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/modctl.h>
35 #include <sys/conf.h>
36 #include <sys/ethernet.h>
37 #include <sys/pci.h>
38 #include <sys/stream.h>
39 #include <sys/strsun.h>
40 #include <sys/processor.h>
41 #include <sys/cpuvar.h>
42 #include <sys/pghw.h>
43
44 #include "sfxge.h"
45 #include "sfxge_version.h"
46 #include "efsys.h"
47 #include "efx.h"
48
49 #ifdef DEBUG
50 boolean_t sfxge_aask = B_FALSE;
51 #endif
52
53 /* Receive queue TRIM default polling interval (in microseconds) */
54 #define SFXGE_RX_QPOLL_USEC (5000000)
55
56 /* Broadcast address */
57 uint8_t sfxge_brdcst[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
58
59 /*
60 * By default modinfo will display lines truncated to 80 characters and so just
61 * show 32 characters of our sfxge_ident string.
62 */
63 const char sfxge_ident[] = "Solarflare 10Gb/40Gb Ethernet";
64 const char sfxge_version[] = SFXGE_VERSION_STRING;
65
66 static void
67 sfxge_cfg_build(sfxge_t *sp)
68 {
69 const efx_nic_cfg_t *encp = efx_nic_cfg_get(sp->s_enp);
70 (void) snprintf(sp->s_cfg_kstat.buf.sck_mac, 64,
71 "%02X:%02X:%02X:%02X:%02X:%02X",
72 encp->enc_mac_addr[0], encp->enc_mac_addr[1],
73 encp->enc_mac_addr[2], encp->enc_mac_addr[3],
74 encp->enc_mac_addr[4], encp->enc_mac_addr[5]);
75 }
76
77 static int
78 sfxge_create(dev_info_t *dip, sfxge_t **spp)
79 {
80 sfxge_t *sp;
81 efx_nic_t *enp;
82 unsigned int rxq_size;
83 int rxq_poll_usec;
84 int rc;
85
86 /* Allocate the object */
87 sp = kmem_zalloc(sizeof (*sp), KM_SLEEP);
88 sp->s_dip = dip;
89 ddi_set_driver_private(dip, sp);
90
91 mutex_init(&(sp->s_state_lock), NULL, MUTEX_DRIVER, NULL);
92 sp->s_state = SFXGE_UNINITIALIZED;
93
94 /* Get property values */
95 sp->s_mtu = ddi_prop_get_int(DDI_DEV_T_ANY, sp->s_dip,
96 DDI_PROP_DONTPASS, "mtu", ETHERMTU);
97
98 sp->s_action_on_hw_err = ddi_prop_get_int(DDI_DEV_T_ANY, sp->s_dip,
99 DDI_PROP_DONTPASS, "action_on_hw_err", SFXGE_RECOVER);
100
101 rxq_size = ddi_prop_get_int(DDI_DEV_T_ANY, sp->s_dip,
102 DDI_PROP_DONTPASS, "rxq_size", SFXGE_DEFAULT_RXQ_SIZE);
103 if (!(ISP2(rxq_size)))
104 rxq_size = SFXGE_DEFAULT_RXQ_SIZE;
105 rxq_size = min(rxq_size, EFX_RXQ_MAXNDESCS);
106 sp->s_rxq_size = (uint16_t)max(rxq_size, EFX_RXQ_MINNDESCS);
107
108 /* Configure polling interval for queue refill/trim */
109 rxq_poll_usec = ddi_prop_get_int(DDI_DEV_T_ANY, sp->s_dip,
110 DDI_PROP_DONTPASS, "rxq_poll_usec", SFXGE_RX_QPOLL_USEC);
111 if (rxq_poll_usec <= 0)
112 rxq_poll_usec = SFXGE_RX_QPOLL_USEC;
113 sp->s_rxq_poll_usec = rxq_poll_usec;
114
115 #if EFSYS_OPT_MCDI_LOGGING
116 sp->s_mcdi_logging = ddi_prop_get_int(DDI_DEV_T_ANY, sp->s_dip,
117 DDI_PROP_DONTPASS, "mcdi_logging", 0);
118 #endif
119
120 /* Create a taskq */
121 sp->s_tqp = ddi_taskq_create(dip, "tq", 1, TASKQ_DEFAULTPRI, 0);
122 if (sp->s_tqp == NULL) {
123 rc = ENOMEM;
124 goto fail2;
125 }
126
127 /* Check and initialize PCI configuration space */
128 if ((rc = sfxge_pci_init(sp)) != 0)
129 goto fail3;
130
131 /* Map the device registers */
132 if ((rc = sfxge_bar_init(sp)) != 0)
133 goto fail4;
134
135 /* Create the NIC object */
136 mutex_init(&(sp->s_nic_lock), NULL, MUTEX_DRIVER, NULL);
137
138 if ((rc = efx_nic_create(sp->s_family, (efsys_identifier_t *)sp,
139 &(sp->s_bar), &(sp->s_nic_lock), &enp)) != 0)
140 goto fail5;
141
142 sp->s_enp = enp;
143
144 /* Initialize MCDI to talk to the Microcontroller */
145 if ((rc = sfxge_mcdi_init(sp)) != 0)
146 goto fail6;
147
148 /* Probe the NIC and build the configuration data area */
149 if ((rc = efx_nic_probe(enp)) != 0)
150 goto fail7;
151
152 switch (sp->s_family) {
153 case EFX_FAMILY_HUNTINGTON:
154 sfxge_pcie_check_link(sp, 8, 3); /* PCI 8x Gen3 */
155 break;
156
157 case EFX_FAMILY_SIENA:
158 sfxge_pcie_check_link(sp, 8, 2); /* PCI 8x Gen2 */
159 break;
160
161 default:
162 break;
163 }
164
165 if ((rc = efx_nvram_init(enp)) != 0)
166 goto fail8;
167
168 if ((rc = efx_vpd_init(enp)) != 0)
169 goto fail9;
170
171 if ((rc = efx_nic_reset(enp)) != 0)
172 goto fail10;
173
174 sfxge_sram_init(sp);
175
176 if ((rc = sfxge_intr_init(sp)) != 0)
177 goto fail11;
178
179 if ((rc = sfxge_ev_init(sp)) != 0)
180 goto fail12;
181
182 if ((rc = sfxge_mac_init(sp)) != 0)
183 goto fail13;
184
185 if ((rc = sfxge_rx_init(sp)) != 0)
186 goto fail14;
187
188 if ((rc = sfxge_tx_init(sp)) != 0)
189 goto fail15;
190
191 if ((rc = sfxge_mon_init(sp)) != 0)
192 goto fail16;
193
194 mutex_init(&(sp->s_tx_flush_lock), NULL, MUTEX_DRIVER,
195 DDI_INTR_PRI(sp->s_intr.si_intr_pri));
196 cv_init(&(sp->s_tx_flush_kv), NULL, CV_DRIVER, NULL);
197
198 sp->s_state = SFXGE_INITIALIZED;
199
200 *spp = sp;
201 return (0);
202
203 fail16:
204 DTRACE_PROBE(fail15);
205 sfxge_tx_fini(sp);
206
207 fail15:
208 DTRACE_PROBE(fail14);
209 sfxge_rx_fini(sp);
210
211 fail14:
212 DTRACE_PROBE(fail14);
213 sfxge_mac_fini(sp);
214
215 fail13:
216 DTRACE_PROBE(fail13);
217 sfxge_ev_fini(sp);
218
219 fail12:
220 DTRACE_PROBE(fail12);
221 sfxge_intr_fini(sp);
222
223 fail11:
224 DTRACE_PROBE(fail11);
225 sfxge_sram_fini(sp);
226 (void) efx_nic_reset(sp->s_enp);
227
228 fail10:
229 DTRACE_PROBE(fail10);
230 efx_vpd_fini(enp);
231
232 fail9:
233 DTRACE_PROBE(fail9);
234 efx_nvram_fini(enp);
235
236 fail8:
237 DTRACE_PROBE(fail8);
238 efx_nic_unprobe(enp);
239
240 fail7:
241 DTRACE_PROBE(fail7);
242 sfxge_mcdi_fini(sp);
243
244 fail6:
245 DTRACE_PROBE(fail6);
246 sp->s_enp = NULL;
247 efx_nic_destroy(enp);
248
249 fail5:
250 DTRACE_PROBE(fail5);
251 mutex_destroy(&(sp->s_nic_lock));
252 sfxge_bar_fini(sp);
253
254 fail4:
255 DTRACE_PROBE(fail4);
256 sfxge_pci_fini(sp);
257
258 fail3:
259 DTRACE_PROBE(fail3);
260 ddi_taskq_destroy(sp->s_tqp);
261 sp->s_tqp = NULL;
262
263 fail2:
264 DTRACE_PROBE(fail2);
265
266 /* Clear property values */
267 sp->s_mtu = 0;
268
269 mutex_destroy(&(sp->s_state_lock));
270
271 /* Free the soft state */
272 sp->s_dip = NULL;
273
274 SFXGE_OBJ_CHECK(sp, sfxge_t);
275 kmem_free(sp, sizeof (*sp));
276
277 return (rc);
278 }
279
280
281 static int
282 sfxge_start_locked(sfxge_t *sp, boolean_t restart)
283 {
284 int rc;
285
286 ASSERT(mutex_owned(&(sp->s_state_lock)));
287
288 if (sp->s_state == SFXGE_STARTED)
289 goto done;
290
291 if (sp->s_state != SFXGE_REGISTERED) {
292 rc = EINVAL;
293 goto fail1;
294 }
295 sp->s_state = SFXGE_STARTING;
296
297 /* Start a new epoch (allow fresh MCDI requests to succeed) */
298 efx_mcdi_new_epoch(sp->s_enp);
299
300 if ((rc = efx_nic_reset(sp->s_enp)) != 0)
301 goto fail2;
302
303 if ((rc = efx_nic_init(sp->s_enp)) != 0)
304 goto fail3;
305
306 if ((rc = efx_filter_init(sp->s_enp)) != 0)
307 goto fail4;
308
309 if ((rc = sfxge_sram_start(sp)) != 0)
310 goto fail5;
311
312 if ((rc = sfxge_intr_start(sp)) != 0)
313 goto fail6;
314
315 if ((rc = sfxge_ev_start(sp)) != 0)
316 goto fail7;
317
318 if ((rc = sfxge_mac_start(sp, restart)) != 0)
319 goto fail8;
320
321 if ((rc = sfxge_rx_start(sp)) != 0)
322 goto fail9;
323
324 if ((rc = sfxge_tx_start(sp)) != 0)
325 goto fail10;
326
327 if ((rc = sfxge_mon_start(sp)) != 0)
328 goto fail11;
329
330 ASSERT3U(sp->s_state, ==, SFXGE_STARTING);
331 sp->s_state = SFXGE_STARTED;
332
333 /* Notify any change of MTU */
334 sfxge_gld_mtu_update(sp);
335
336 done:
337 return (0);
338
339 fail11:
340 DTRACE_PROBE(fail11);
341 sfxge_tx_stop(sp);
342
343 fail10:
344 DTRACE_PROBE(fail10);
345 sfxge_rx_stop(sp);
346
347 fail9:
348 DTRACE_PROBE(fail9);
349 sfxge_mac_stop(sp);
350
351 fail8:
352 DTRACE_PROBE(fail8);
353 sfxge_ev_stop(sp);
354
355 fail7:
356 DTRACE_PROBE(fail7);
357 sfxge_intr_stop(sp);
358
359 fail6:
360 DTRACE_PROBE(fail6);
361 sfxge_sram_stop(sp);
362
363 fail5:
364 DTRACE_PROBE(fail5);
365 efx_filter_fini(sp->s_enp);
366
367 fail4:
368 DTRACE_PROBE(fail4);
369 efx_nic_fini(sp->s_enp);
370
371 fail3:
372 DTRACE_PROBE(fail3);
373 (void) efx_nic_reset(sp->s_enp);
374
375 fail2:
376 DTRACE_PROBE(fail2);
377
378 ASSERT3U(sp->s_state, ==, SFXGE_STARTING);
379 sp->s_state = SFXGE_REGISTERED;
380
381 fail1:
382 DTRACE_PROBE1(fail1, int, rc);
383
384 return (rc);
385 }
386
387
388 int
389 sfxge_start(sfxge_t *sp, boolean_t restart)
390 {
391 int rc;
392
393 mutex_enter(&(sp->s_state_lock));
394 rc = sfxge_start_locked(sp, restart);
395 mutex_exit(&(sp->s_state_lock));
396 return (rc);
397 }
398
399
400 static void
401 sfxge_stop_locked(sfxge_t *sp)
402 {
403 ASSERT(mutex_owned(&(sp->s_state_lock)));
404
405 if (sp->s_state != SFXGE_STARTED) {
406 return;
407 }
408 sp->s_state = SFXGE_STOPPING;
409
410 sfxge_mon_stop(sp);
411 sfxge_tx_stop(sp);
412 sfxge_rx_stop(sp);
413 sfxge_mac_stop(sp);
414
415 /* Stop event processing - must be after rx_stop see sfxge_rx_qpoll() */
416 sfxge_ev_stop(sp);
417 sfxge_intr_stop(sp); /* cope with late flush/soft events until here */
418 sfxge_sram_stop(sp);
419
420 efx_filter_fini(sp->s_enp);
421
422 efx_nic_fini(sp->s_enp);
423 (void) efx_nic_reset(sp->s_enp);
424
425 ASSERT3U(sp->s_state, ==, SFXGE_STOPPING);
426 sp->s_state = SFXGE_REGISTERED;
427 }
428
429 void
430 sfxge_stop(sfxge_t *sp)
431 {
432 mutex_enter(&(sp->s_state_lock));
433 sfxge_stop_locked(sp);
434 mutex_exit(&(sp->s_state_lock));
435 }
436
437 static void
438 _sfxge_restart(void *arg)
439 {
440 sfxge_t *sp = arg;
441 int rc;
442
443 /* logging on entry is in sfxge_restart_dispatch */
444 mutex_enter(&(sp->s_state_lock));
445
446 DTRACE_PROBE(_sfxge_restart);
447 if (sp->s_state != SFXGE_STARTED)
448 goto done;
449
450 /* inform the OS that the link is down - may trigger IPMP failover */
451 if (sp->s_hw_err && sp->s_action_on_hw_err != SFXGE_INVISIBLE) {
452 sp->s_mac.sm_link_mode = EFX_LINK_DOWN;
453 sfxge_gld_link_update(sp);
454 }
455
456 /* Stop processing */
457 sfxge_stop_locked(sp);
458
459 if (sp->s_hw_err && sp->s_action_on_hw_err == SFXGE_LEAVE_DEAD) {
460 dev_err(sp->s_dip, CE_WARN, SFXGE_CMN_ERR
461 "NIC error - interface is"
462 " being left permanently DOWN per driver config");
463
464 (void) atomic_swap_32(&(sp->s_nested_restarts), 0);
465 mutex_exit(&(sp->s_state_lock));
466 return;
467 } else
468 sp->s_hw_err = SFXGE_HW_OK;
469
470 /* Start processing */
471 if ((rc = sfxge_start_locked(sp, B_TRUE)) != 0)
472 goto fail1;
473
474 done:
475 (void) atomic_swap_32(&(sp->s_nested_restarts), 0);
476 mutex_exit(&(sp->s_state_lock));
477 dev_err(sp->s_dip, CE_WARN, SFXGE_CMN_ERR "NIC restart complete");
478 return;
479
480 fail1:
481 DTRACE_PROBE1(fail1, int, rc);
482 dev_err(sp->s_dip, CE_WARN,
483 SFXGE_CMN_ERR "FATAL ERROR: NIC restart failed rc=%d", rc);
484
485 (void) atomic_swap_32(&(sp->s_nested_restarts), 0);
486 mutex_exit(&(sp->s_state_lock));
487 }
488
489 int
490 sfxge_restart_dispatch(sfxge_t *sp, uint_t cflags, sfxge_hw_err_t hw_err,
491 const char *reason, uint32_t errval)
492 {
493 if (hw_err == SFXGE_HW_OK)
494 sp->s_num_restarts++;
495 else {
496 sp->s_hw_err = hw_err;
497 sp->s_num_restarts_hw_err++;
498 }
499
500 if (atomic_inc_32_nv(&(sp->s_nested_restarts)) > 1) {
501 /* A restart is currently in progress */
502 return (0);
503 }
504
505 DTRACE_PROBE2(sfxge_restart_dispatch, sfxge_hw_err_t, hw_err, char *,
506 reason);
507
508 dev_err(sp->s_dip, CE_WARN, SFXGE_CMN_ERR "NIC restart due to %s:%d",
509 reason, errval);
510
511 /* If cflags == DDI_SLEEP then guaranteed to succeed */
512 return (ddi_taskq_dispatch(sp->s_tqp, _sfxge_restart, sp, cflags));
513 }
514
515
516 static int
517 sfxge_can_destroy(sfxge_t *sp)
518 {
519 int index;
520
521 /*
522 * In SFC bug 19834 it was noted that a mblk passed up to STREAMS
523 * could be reused for transmit and sit in the sfxge_tx_packet_cache.
524 * This call to empty the TX deferred packet list may result in
525 * rx_loaned reducing.
526 */
527 index = EFX_ARRAY_SIZE(sp->s_stp);
528 while (--index >= 0) {
529 sfxge_txq_t *stp = sp->s_stp[index];
530
531 if (stp != NULL)
532 sfxge_tx_qdpl_flush(stp);
533 }
534
535 /* Need to wait for desballoc free_func callback */
536 return (sfxge_rx_loaned(sp));
537 }
538
539
540 static int
541 sfxge_destroy(sfxge_t *sp)
542 {
543 ddi_taskq_t *tqp;
544 efx_nic_t *enp;
545 int rc;
546
547 ASSERT3U(sp->s_state, ==, SFXGE_INITIALIZED);
548 enp = sp->s_enp;
549
550 if (sfxge_can_destroy(sp) != 0) {
551 rc = EBUSY;
552 goto fail1;
553 }
554
555 sp->s_state = SFXGE_UNINITIALIZED;
556
557 cv_destroy(&(sp->s_tx_flush_kv));
558 mutex_destroy(&(sp->s_tx_flush_lock));
559
560 sfxge_mon_fini(sp);
561 sfxge_tx_fini(sp);
562 sfxge_rx_fini(sp);
563 sfxge_mac_fini(sp);
564 sfxge_ev_fini(sp);
565 sfxge_intr_fini(sp);
566 sfxge_sram_fini(sp);
567 (void) efx_nic_reset(enp);
568
569 efx_vpd_fini(enp);
570 efx_nvram_fini(enp);
571 efx_nic_unprobe(enp);
572 sfxge_mcdi_fini(sp);
573
574 /* Destroy the NIC object */
575 sp->s_enp = NULL;
576 efx_nic_destroy(enp);
577
578 mutex_destroy(&(sp->s_nic_lock));
579
580 /* Unmap the device registers */
581 sfxge_bar_fini(sp);
582
583 /* Tear down PCI configuration space */
584 sfxge_pci_fini(sp);
585
586 /* Destroy the taskq */
587 tqp = sp->s_tqp;
588 sp->s_tqp = NULL;
589 ddi_taskq_destroy(tqp);
590
591 mutex_destroy(&(sp->s_state_lock));
592
593 /* Clear property values */
594 sp->s_mtu = 0;
595
596 /* Free the soft state */
597 sp->s_dip = NULL;
598
599 SFXGE_OBJ_CHECK(sp, sfxge_t);
600 kmem_free(sp, sizeof (*sp));
601
602 return (0);
603
604 fail1:
605 DTRACE_PROBE1(fail1, int, rc);
606
607 return (rc);
608 }
609
610 void
611 sfxge_ioctl(sfxge_t *sp, queue_t *wq, mblk_t *mp)
612 {
613 struct iocblk *iocp;
614 int rc, taskq_wait = 0;
615 size_t ioclen = 0;
616
617 /*
618 * single concurrent IOCTL
619 * serialized from sfxge_create, _destroy, _(re)start, _stop
620 */
621 mutex_enter(&(sp->s_state_lock));
622
623 /*LINTED*/
624 iocp = (struct iocblk *)mp->b_rptr;
625
626 switch (iocp->ioc_cmd) {
627 case SFXGE_NVRAM_IOC:
628 ioclen = sizeof (sfxge_nvram_ioc_t);
629 break;
630 case SFXGE_MCDI_IOC:
631 ioclen = sizeof (sfxge_mcdi_ioc_t);
632 break;
633 case SFXGE_MCDI2_IOC:
634 ioclen = sizeof (sfxge_mcdi2_ioc_t);
635 break;
636 case SFXGE_VPD_IOC:
637 ioclen = sizeof (sfxge_vpd_ioc_t);
638 break;
639 case SFXGE_NIC_RESET_IOC:
640 break;
641 default:
642 rc = ENOTSUP;
643 goto fail1;
644 }
645
646 if (iocp->ioc_count != ioclen) {
647 rc = EINVAL;
648 goto fail2;
649 }
650
651 /* if in multiple fragments pull it up to one linear buffer */
652 if ((rc = miocpullup(mp, ioclen)) != 0) {
653 goto fail3;
654 }
655
656 switch (iocp->ioc_cmd) {
657 case SFXGE_NVRAM_IOC: {
658 sfxge_nvram_ioc_t *snip =
659 (sfxge_nvram_ioc_t *)mp->b_cont->b_rptr;
660
661 if ((rc = sfxge_nvram_ioctl(sp, snip)) != 0)
662 goto fail4;
663
664 break;
665 }
666 case SFXGE_MCDI_IOC: {
667 sfxge_mcdi_ioc_t *smip = (sfxge_mcdi_ioc_t *)mp->b_cont->b_rptr;
668
669 if ((rc = sfxge_mcdi_ioctl(sp, smip)) != 0)
670 goto fail4;
671 taskq_wait = 1;
672
673 break;
674 }
675 case SFXGE_MCDI2_IOC: {
676 sfxge_mcdi2_ioc_t *smip =
677 (sfxge_mcdi2_ioc_t *)mp->b_cont->b_rptr;
678
679 if ((rc = sfxge_mcdi2_ioctl(sp, smip)) != 0)
680 goto fail4;
681 taskq_wait = 1;
682
683 break;
684 }
685 case SFXGE_NIC_RESET_IOC: {
686 DTRACE_PROBE(nic_reset_ioc);
687
688 /* sp->s_state_lock held */
689 (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_OK,
690 "NIC_RESET_IOC", 0);
691 taskq_wait = 1;
692
693 break;
694 }
695 case SFXGE_VPD_IOC: {
696 sfxge_vpd_ioc_t *svip = (sfxge_vpd_ioc_t *)mp->b_cont->b_rptr;
697
698 if ((rc = sfxge_vpd_ioctl(sp, svip)) != 0)
699 goto fail4;
700
701 break;
702 }
703 default:
704 ASSERT(0);
705 }
706
707 mutex_exit(&(sp->s_state_lock));
708
709 if (taskq_wait) {
710 /*
711 * Wait for any tasks that may be accessing GLD functions
712 * This may end up waiting for multiple nic_resets
713 * as it needs to be outside of s_state_lock for sfxge_restart()
714 */
715 ddi_taskq_wait(sp->s_tqp);
716 }
717
718 /* The entire structure is the acknowledgement */
719 miocack(wq, mp, iocp->ioc_count, 0);
720
721 return;
722
723 fail4:
724 DTRACE_PROBE(fail4);
725 fail3:
726 DTRACE_PROBE(fail3);
727 fail2:
728 DTRACE_PROBE(fail2);
729 fail1:
730 DTRACE_PROBE1(fail1, int, rc);
731
732 mutex_exit(&(sp->s_state_lock));
733
734 /* no data returned */
735 miocnak(wq, mp, 0, rc);
736 }
737
738 static int
739 sfxge_register(sfxge_t *sp)
740 {
741 int rc;
742
743 ASSERT3U(sp->s_state, ==, SFXGE_INITIALIZED);
744
745 if ((rc = sfxge_gld_register(sp)) != 0)
746 goto fail1;
747
748 sp->s_state = SFXGE_REGISTERED;
749
750 return (0);
751
752 fail1:
753 DTRACE_PROBE1(fail1, int, rc);
754
755 return (rc);
756 }
757
758 static int
759 sfxge_unregister(sfxge_t *sp)
760 {
761 int rc;
762
763 ASSERT3U(sp->s_state, ==, SFXGE_REGISTERED);
764
765 /* Wait for any tasks that may be accessing GLD functions */
766 ddi_taskq_wait(sp->s_tqp);
767
768 if ((rc = sfxge_gld_unregister(sp)) != 0)
769 goto fail1;
770
771 sp->s_state = SFXGE_INITIALIZED;
772
773 return (0);
774
775 fail1:
776 DTRACE_PROBE1(fail1, int, rc);
777
778 return (rc);
779 }
780
781 static void
782 _sfxge_vpd_kstat_init(sfxge_t *sp, caddr_t vpd, size_t size, efx_vpd_tag_t tag,
783 const char *keyword, sfxge_vpd_type_t type)
784 {
785 static const char unknown[] = "?";
786 efx_nic_t *enp = sp->s_enp;
787 sfxge_vpd_kstat_t *svkp = &(sp->s_vpd_kstat);
788 kstat_named_t *knp;
789 efx_vpd_value_t *evvp;
790
791 evvp = svkp->svk_vv + type;
792 evvp->evv_tag = tag;
793 evvp->evv_keyword = EFX_VPD_KEYWORD(keyword[0], keyword[1]);
794
795 if (efx_vpd_get(enp, vpd, size, evvp) != 0) {
796 evvp->evv_length = strlen(unknown) + 1;
797 bcopy(unknown, evvp->evv_value, evvp->evv_length);
798 }
799
800 knp = &(svkp->svk_stat[type]);
801
802 kstat_named_init(knp, (char *)keyword, KSTAT_DATA_STRING);
803 kstat_named_setstr(knp, (char *)evvp->evv_value);
804 svkp->svk_ksp->ks_data_size += sizeof (*evvp);
805 }
806
807 static int
808 sfxge_vpd_kstat_init(sfxge_t *sp)
809 {
810 efx_nic_t *enp = sp->s_enp;
811 sfxge_vpd_kstat_t *svkp = &(sp->s_vpd_kstat);
812 dev_info_t *dip = sp->s_dip;
813 char name[MAXNAMELEN];
814 kstat_t *ksp;
815 caddr_t vpd;
816 size_t size;
817 int rc;
818
819 SFXGE_OBJ_CHECK(svkp, sfxge_vpd_kstat_t);
820 (void) snprintf(name, MAXNAMELEN - 1, "%s_vpd", ddi_driver_name(dip));
821
822 /* Get a copy of the VPD space */
823 if ((rc = efx_vpd_size(enp, &size)) != 0)
824 goto fail1;
825
826 if ((vpd = kmem_zalloc(size, KM_NOSLEEP)) == NULL) {
827 rc = ENOMEM;
828 goto fail2;
829 }
830
831 if ((svkp->svk_vv = kmem_zalloc(sizeof (efx_vpd_value_t) *
832 SFXGE_VPD_MAX, KM_NOSLEEP)) == NULL) {
833 rc = ENOMEM;
834 goto fail3;
835 }
836
837 if ((rc = efx_vpd_read(enp, vpd, size)) != 0)
838 goto fail4;
839
840 if ((ksp = kstat_create((char *)ddi_driver_name(dip),
841 ddi_get_instance(dip), name, "vpd", KSTAT_TYPE_NAMED, SFXGE_VPD_MAX,
842 KSTAT_FLAG_VIRTUAL)) == NULL) {
843 rc = ENOMEM;
844 goto fail5;
845 }
846 svkp->svk_ksp = ksp;
847 ksp->ks_data = &(svkp->svk_stat);
848
849 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_ID, "ID", SFXGE_VPD_ID);
850 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "PN", SFXGE_VPD_PN);
851 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "SN", SFXGE_VPD_SN);
852 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "EC", SFXGE_VPD_EC);
853 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "MN", SFXGE_VPD_MN);
854 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "VD", SFXGE_VPD_VD);
855 _sfxge_vpd_kstat_init(sp, vpd, size, EFX_VPD_RO, "VE", SFXGE_VPD_VE);
856
857 kstat_install(ksp);
858 kmem_free(vpd, size);
859
860 return (0);
861
862 fail5:
863 DTRACE_PROBE(fail5);
864 fail4:
865 DTRACE_PROBE(fail4);
866 kmem_free(svkp->svk_vv, sizeof (efx_vpd_value_t) * SFXGE_VPD_MAX);
867 fail3:
868 DTRACE_PROBE(fail3);
869 kmem_free(vpd, size);
870 fail2:
871 DTRACE_PROBE(fail2);
872 fail1:
873 DTRACE_PROBE1(fail1, int, rc);
874 SFXGE_OBJ_CHECK(svkp, sfxge_vpd_kstat_t);
875
876 return (rc);
877 }
878
879 static void
880 sfxge_vpd_kstat_fini(sfxge_t *sp)
881 {
882 sfxge_vpd_kstat_t *svkp = &(sp->s_vpd_kstat);
883
884 /* NOTE: VPD support is optional, so kstats might not be registered */
885 if (svkp->svk_ksp != NULL) {
886
887 kstat_delete(svkp->svk_ksp);
888
889 kmem_free(svkp->svk_vv,
890 sizeof (efx_vpd_value_t) * SFXGE_VPD_MAX);
891
892 bzero(svkp->svk_stat,
893 sizeof (kstat_named_t) * SFXGE_VPD_MAX);
894
895 svkp->svk_ksp = NULL;
896 }
897
898 SFXGE_OBJ_CHECK(svkp, sfxge_vpd_kstat_t);
899 }
900
901 static int
902 sfxge_cfg_kstat_init(sfxge_t *sp)
903 {
904 dev_info_t *dip = sp->s_dip;
905 char name[MAXNAMELEN];
906 kstat_t *ksp;
907 sfxge_cfg_kstat_t *sckp;
908 int rc;
909
910 sfxge_cfg_build(sp);
911
912 /* Create the set */
913 (void) snprintf(name, MAXNAMELEN - 1, "%s_cfg", ddi_driver_name(dip));
914
915 if ((ksp = kstat_create((char *)ddi_driver_name(dip),
916 ddi_get_instance(dip), name, "cfg", KSTAT_TYPE_NAMED,
917 sizeof (sckp->kstat) / sizeof (kstat_named_t),
918 KSTAT_FLAG_VIRTUAL)) == NULL) {
919 rc = ENOMEM;
920 goto fail1;
921 }
922
923 sp->s_cfg_ksp = ksp;
924
925 ksp->ks_data = sckp = &(sp->s_cfg_kstat);
926
927 kstat_named_init(&(sckp->kstat.sck_mac), "mac", KSTAT_DATA_STRING);
928 kstat_named_setstr(&(sckp->kstat.sck_mac), sckp->buf.sck_mac);
929 ksp->ks_data_size += sizeof (sckp->buf.sck_mac);
930
931 kstat_named_init(&(sckp->kstat.sck_version), "version",
932 KSTAT_DATA_STRING);
933 kstat_named_setstr(&(sckp->kstat.sck_version), sfxge_version);
934 ksp->ks_data_size += sizeof (sfxge_version);
935
936 kstat_install(ksp);
937 return (0);
938
939 fail1:
940 DTRACE_PROBE1(fail1, int, rc);
941
942 return (rc);
943 }
944
945 static void
946 sfxge_cfg_kstat_fini(sfxge_t *sp)
947 {
948 if (sp->s_cfg_ksp == NULL)
949 return;
950
951 kstat_delete(sp->s_cfg_ksp);
952 sp->s_cfg_ksp = NULL;
953
954 bzero(&(sp->s_cfg_kstat), sizeof (sfxge_cfg_kstat_t));
955 }
956
957 static int
958 sfxge_resume(sfxge_t *sp)
959 {
960 int rc;
961
962 /* Start processing */
963 if ((rc = sfxge_start(sp, B_FALSE)) != 0)
964 goto fail1;
965
966 return (DDI_SUCCESS);
967
968 fail1:
969 DTRACE_PROBE1(fail1, int, rc);
970
971 return (DDI_FAILURE);
972 }
973
974 static int
975 sfxge_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
976 {
977 sfxge_t *sp;
978 int rc;
979
980 switch (cmd) {
981 case DDI_ATTACH:
982 break;
983
984 case DDI_RESUME:
985 if ((sp = ddi_get_driver_private(dip)) == NULL)
986 return (DDI_FAILURE);
987 return (sfxge_resume(sp));
988
989 default:
990 return (DDI_FAILURE);
991 }
992
993 /* Create the soft state */
994 if ((rc = sfxge_create(dip, &sp)) != 0)
995 goto fail1;
996
997 /* Create the configuration kstats */
998 if ((rc = sfxge_cfg_kstat_init(sp)) != 0)
999 goto fail2;
1000
1001 /* Create the VPD kstats */
1002 if ((rc = sfxge_vpd_kstat_init(sp)) != 0) {
1003 if (rc != ENOTSUP)
1004 goto fail3;
1005 }
1006
1007 /* Register the interface */
1008 if ((rc = sfxge_register(sp)) != 0)
1009 goto fail4;
1010
1011 /* Announce ourselves in the system log */
1012 ddi_report_dev(dip);
1013
1014 return (DDI_SUCCESS);
1015
1016 fail4:
1017 DTRACE_PROBE(fail4);
1018
1019 /* Destroy the VPD kstats */
1020 sfxge_vpd_kstat_fini(sp);
1021
1022 fail3:
1023 DTRACE_PROBE(fail3);
1024
1025 /* Destroy the configuration kstats */
1026 sfxge_cfg_kstat_fini(sp);
1027
1028 fail2:
1029 DTRACE_PROBE(fail2);
1030
1031 /* Destroy the soft state */
1032 (void) sfxge_destroy(sp);
1033
1034 fail1:
1035 DTRACE_PROBE1(fail1, int, rc);
1036
1037 return (DDI_FAILURE);
1038 }
1039
1040 static int
1041 sfxge_suspend(sfxge_t *sp)
1042 {
1043 /* Stop processing */
1044 sfxge_stop(sp);
1045
1046 return (DDI_SUCCESS);
1047 }
1048
1049 static int
1050 sfxge_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1051 {
1052 sfxge_t *sp = ddi_get_driver_private(dip);
1053 int rc;
1054
1055 switch (cmd) {
1056 case DDI_DETACH:
1057 if (sp == NULL)
1058 return (DDI_FAILURE);
1059 break;
1060
1061 case DDI_SUSPEND:
1062 if (sp == NULL)
1063 return (DDI_FAILURE);
1064 return (sfxge_suspend(sp));
1065
1066 default:
1067 return (DDI_FAILURE);
1068 }
1069
1070 ASSERT(sp != NULL);
1071
1072 /* Wait for any pending restarts to complete */
1073 ddi_taskq_wait(sp->s_tqp);
1074
1075 /*
1076 * IOCTLs from utilites can cause GLD mc_start() (SFXGE_STARTED state)
1077 * And mc_stop() may not occur until detach time and race. SFC bug 19855
1078 * Holding the lock seems to be enough - the log message is not seen
1079 */
1080 mutex_enter(&(sp->s_state_lock));
1081 if (sp->s_state == SFXGE_STARTED) {
1082 dev_err(dip, CE_WARN, SFXGE_CMN_ERR
1083 "STREAMS detach when STARTED");
1084 sfxge_stop_locked(sp);
1085 ASSERT3U(sp->s_state, ==, SFXGE_REGISTERED);
1086 }
1087 mutex_exit(&(sp->s_state_lock));
1088
1089 ASSERT(sp->s_state == SFXGE_REGISTERED ||
1090 sp->s_state == SFXGE_INITIALIZED);
1091
1092 if (sp->s_state != SFXGE_REGISTERED)
1093 goto destroy;
1094
1095 /* Unregister the interface */
1096 if ((rc = sfxge_unregister(sp)) != 0)
1097 goto fail1;
1098
1099 destroy:
1100 /* Destroy the VPD kstats */
1101 sfxge_vpd_kstat_fini(sp);
1102
1103 /* Destroy the configuration kstats */
1104 sfxge_cfg_kstat_fini(sp);
1105
1106 /*
1107 * Destroy the soft state - this might fail until rx_loaned packets that
1108 * have been passed up the STREAMS stack are returned
1109 */
1110 if ((rc = sfxge_destroy(sp)) != 0)
1111 goto fail2;
1112
1113 return (DDI_SUCCESS);
1114
1115 fail2:
1116 DTRACE_PROBE(fail2);
1117 fail1:
1118 DTRACE_PROBE1(fail1, int, rc);
1119
1120 return (DDI_FAILURE);
1121 }
1122
1123 /*
1124 * modlinkage
1125 */
1126
1127 DDI_DEFINE_STREAM_OPS(sfxge_dev_ops, nulldev, nulldev, sfxge_attach,
1128 sfxge_detach, nulldev, NULL, D_MP, NULL, NULL);
1129
1130 static struct modldrv sfxge_modldrv = {
1131 &mod_driverops,
1132 (char *)sfxge_ident,
1133 &sfxge_dev_ops,
1134 };
1135
1136 static struct modlinkage sfxge_modlinkage = {
1137 MODREV_1,
1138 { &sfxge_modldrv, NULL }
1139 };
1140
1141 kmutex_t sfxge_global_lock;
1142 unsigned int *sfxge_cpu;
1143
1144 int
1145 _init(void)
1146 {
1147 int rc;
1148
1149 mutex_init(&sfxge_global_lock, NULL, MUTEX_DRIVER, NULL);
1150
1151 /* Create tables for CPU, core, cache and chip counts */
1152 sfxge_cpu = kmem_zalloc(sizeof (unsigned int) * NCPU, KM_SLEEP);
1153
1154 mac_init_ops(&sfxge_dev_ops, SFXGE_DRIVER_NAME);
1155
1156 if ((rc = mod_install(&sfxge_modlinkage)) != 0)
1157 goto fail1;
1158
1159 return (0);
1160
1161 fail1:
1162 DTRACE_PROBE(fail2);
1163
1164 mac_fini_ops(&sfxge_dev_ops);
1165
1166 kmem_free(sfxge_cpu, sizeof (unsigned int) * NCPU);
1167 mutex_destroy(&sfxge_global_lock);
1168
1169 return (rc);
1170 }
1171
1172 int
1173 _fini(void)
1174 {
1175 int rc;
1176
1177 if ((rc = mod_remove(&sfxge_modlinkage)) != 0)
1178 return (rc);
1179
1180 mac_fini_ops(&sfxge_dev_ops);
1181
1182 /* Destroy tables */
1183 kmem_free(sfxge_cpu, sizeof (unsigned int) * NCPU);
1184
1185 mutex_destroy(&sfxge_global_lock);
1186
1187 return (0);
1188 }
1189
1190 int
1191 _info(struct modinfo *mip)
1192 {
1193 return (mod_info(&sfxge_modlinkage, mip));
1194 }