net/ixgbe/base: remove X550em SFP iXFI setup
[dpdk.git] / drivers / net / sfc / sfc.c
1 /*-
2  * Copyright (c) 2016 Solarflare Communications Inc.
3  * All rights reserved.
4  *
5  * This software was jointly developed between OKTET Labs (under contract
6  * for Solarflare) and Solarflare Communications, Inc.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright notice,
12  *    this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright notice,
14  *    this list of conditions and the following disclaimer in the documentation
15  *    and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
27  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 /* sysconf() */
31 #include <unistd.h>
32
33 #include <rte_errno.h>
34
35 #include "efx.h"
36
37 #include "sfc.h"
38 #include "sfc_log.h"
39 #include "sfc_ev.h"
40 #include "sfc_rx.h"
41 #include "sfc_tx.h"
42
43
44 int
45 sfc_dma_alloc(const struct sfc_adapter *sa, const char *name, uint16_t id,
46               size_t len, int socket_id, efsys_mem_t *esmp)
47 {
48         const struct rte_memzone *mz;
49
50         sfc_log_init(sa, "name=%s id=%u len=%lu socket_id=%d",
51                      name, id, len, socket_id);
52
53         mz = rte_eth_dma_zone_reserve(sa->eth_dev, name, id, len,
54                                       sysconf(_SC_PAGESIZE), socket_id);
55         if (mz == NULL) {
56                 sfc_err(sa, "cannot reserve DMA zone for %s:%u %#x@%d: %s",
57                         name, (unsigned int)id, (unsigned int)len, socket_id,
58                         rte_strerror(rte_errno));
59                 return ENOMEM;
60         }
61
62         esmp->esm_addr = rte_mem_phy2mch(mz->memseg_id, mz->phys_addr);
63         if (esmp->esm_addr == RTE_BAD_PHYS_ADDR) {
64                 (void)rte_memzone_free(mz);
65                 return EFAULT;
66         }
67
68         esmp->esm_mz = mz;
69         esmp->esm_base = mz->addr;
70
71         return 0;
72 }
73
74 void
75 sfc_dma_free(const struct sfc_adapter *sa, efsys_mem_t *esmp)
76 {
77         int rc;
78
79         sfc_log_init(sa, "name=%s", esmp->esm_mz->name);
80
81         rc = rte_memzone_free(esmp->esm_mz);
82         if (rc != 0)
83                 sfc_err(sa, "rte_memzone_free(() failed: %d", rc);
84
85         memset(esmp, 0, sizeof(*esmp));
86 }
87
88 static uint32_t
89 sfc_phy_cap_from_link_speeds(uint32_t speeds)
90 {
91         uint32_t phy_caps = 0;
92
93         if (~speeds & ETH_LINK_SPEED_FIXED) {
94                 phy_caps |= (1 << EFX_PHY_CAP_AN);
95                 /*
96                  * If no speeds are specified in the mask, any supported
97                  * may be negotiated
98                  */
99                 if (speeds == ETH_LINK_SPEED_AUTONEG)
100                         phy_caps |=
101                                 (1 << EFX_PHY_CAP_1000FDX) |
102                                 (1 << EFX_PHY_CAP_10000FDX) |
103                                 (1 << EFX_PHY_CAP_40000FDX);
104         }
105         if (speeds & ETH_LINK_SPEED_1G)
106                 phy_caps |= (1 << EFX_PHY_CAP_1000FDX);
107         if (speeds & ETH_LINK_SPEED_10G)
108                 phy_caps |= (1 << EFX_PHY_CAP_10000FDX);
109         if (speeds & ETH_LINK_SPEED_40G)
110                 phy_caps |= (1 << EFX_PHY_CAP_40000FDX);
111
112         return phy_caps;
113 }
114
115 /*
116  * Check requested device level configuration.
117  * Receive and transmit configuration is checked in corresponding
118  * modules.
119  */
120 static int
121 sfc_check_conf(struct sfc_adapter *sa)
122 {
123         const struct rte_eth_conf *conf = &sa->eth_dev->data->dev_conf;
124         int rc = 0;
125
126         sa->port.phy_adv_cap =
127                 sfc_phy_cap_from_link_speeds(conf->link_speeds) &
128                 sa->port.phy_adv_cap_mask;
129         if ((sa->port.phy_adv_cap & ~(1 << EFX_PHY_CAP_AN)) == 0) {
130                 sfc_err(sa, "No link speeds from mask %#x are supported",
131                         conf->link_speeds);
132                 rc = EINVAL;
133         }
134
135         if (conf->lpbk_mode != 0) {
136                 sfc_err(sa, "Loopback not supported");
137                 rc = EINVAL;
138         }
139
140         if (conf->dcb_capability_en != 0) {
141                 sfc_err(sa, "Priority-based flow control not supported");
142                 rc = EINVAL;
143         }
144
145         if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) {
146                 sfc_err(sa, "Flow Director not supported");
147                 rc = EINVAL;
148         }
149
150         if ((conf->intr_conf.lsc != 0) &&
151             (sa->intr.type != EFX_INTR_LINE) &&
152             (sa->intr.type != EFX_INTR_MESSAGE)) {
153                 sfc_err(sa, "Link status change interrupt not supported");
154                 rc = EINVAL;
155         }
156
157         if (conf->intr_conf.rxq != 0) {
158                 sfc_err(sa, "Receive queue interrupt not supported");
159                 rc = EINVAL;
160         }
161
162         return rc;
163 }
164
165 /*
166  * Find out maximum number of receive and transmit queues which could be
167  * advertised.
168  *
169  * NIC is kept initialized on success to allow other modules acquire
170  * defaults and capabilities.
171  */
172 static int
173 sfc_estimate_resource_limits(struct sfc_adapter *sa)
174 {
175         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
176         efx_drv_limits_t limits;
177         int rc;
178         uint32_t evq_allocated;
179         uint32_t rxq_allocated;
180         uint32_t txq_allocated;
181
182         memset(&limits, 0, sizeof(limits));
183
184         /* Request at least one Rx and Tx queue */
185         limits.edl_min_rxq_count = 1;
186         limits.edl_min_txq_count = 1;
187         /* Management event queue plus event queue for each Tx and Rx queue */
188         limits.edl_min_evq_count =
189                 1 + limits.edl_min_rxq_count + limits.edl_min_txq_count;
190
191         /* Divide by number of functions to guarantee that all functions
192          * will get promised resources
193          */
194         /* FIXME Divide by number of functions (not 2) below */
195         limits.edl_max_evq_count = encp->enc_evq_limit / 2;
196         SFC_ASSERT(limits.edl_max_evq_count >= limits.edl_min_rxq_count);
197
198         /* Split equally between receive and transmit */
199         limits.edl_max_rxq_count =
200                 MIN(encp->enc_rxq_limit, (limits.edl_max_evq_count - 1) / 2);
201         SFC_ASSERT(limits.edl_max_rxq_count >= limits.edl_min_rxq_count);
202
203         limits.edl_max_txq_count =
204                 MIN(encp->enc_txq_limit,
205                     limits.edl_max_evq_count - 1 - limits.edl_max_rxq_count);
206
207         if (sa->tso)
208                 limits.edl_max_txq_count =
209                         MIN(limits.edl_max_txq_count,
210                             encp->enc_fw_assisted_tso_v2_n_contexts /
211                             encp->enc_hw_pf_count);
212
213         SFC_ASSERT(limits.edl_max_txq_count >= limits.edl_min_rxq_count);
214
215         /* Configure the minimum required resources needed for the
216          * driver to operate, and the maximum desired resources that the
217          * driver is capable of using.
218          */
219         efx_nic_set_drv_limits(sa->nic, &limits);
220
221         sfc_log_init(sa, "init nic");
222         rc = efx_nic_init(sa->nic);
223         if (rc != 0)
224                 goto fail_nic_init;
225
226         /* Find resource dimensions assigned by firmware to this function */
227         rc = efx_nic_get_vi_pool(sa->nic, &evq_allocated, &rxq_allocated,
228                                  &txq_allocated);
229         if (rc != 0)
230                 goto fail_get_vi_pool;
231
232         /* It still may allocate more than maximum, ensure limit */
233         evq_allocated = MIN(evq_allocated, limits.edl_max_evq_count);
234         rxq_allocated = MIN(rxq_allocated, limits.edl_max_rxq_count);
235         txq_allocated = MIN(txq_allocated, limits.edl_max_txq_count);
236
237         /* Subtract management EVQ not used for traffic */
238         SFC_ASSERT(evq_allocated > 0);
239         evq_allocated--;
240
241         /* Right now we use separate EVQ for Rx and Tx */
242         sa->rxq_max = MIN(rxq_allocated, evq_allocated / 2);
243         sa->txq_max = MIN(txq_allocated, evq_allocated - sa->rxq_max);
244
245         /* Keep NIC initialized */
246         return 0;
247
248 fail_get_vi_pool:
249 fail_nic_init:
250         efx_nic_fini(sa->nic);
251         return rc;
252 }
253
254 static int
255 sfc_set_drv_limits(struct sfc_adapter *sa)
256 {
257         const struct rte_eth_dev_data *data = sa->eth_dev->data;
258         efx_drv_limits_t lim;
259
260         memset(&lim, 0, sizeof(lim));
261
262         /* Limits are strict since take into account initial estimation */
263         lim.edl_min_evq_count = lim.edl_max_evq_count =
264                 1 + data->nb_rx_queues + data->nb_tx_queues;
265         lim.edl_min_rxq_count = lim.edl_max_rxq_count = data->nb_rx_queues;
266         lim.edl_min_txq_count = lim.edl_max_txq_count = data->nb_tx_queues;
267
268         return efx_nic_set_drv_limits(sa->nic, &lim);
269 }
270
271 int
272 sfc_start(struct sfc_adapter *sa)
273 {
274         int rc;
275
276         sfc_log_init(sa, "entry");
277
278         SFC_ASSERT(sfc_adapter_is_locked(sa));
279
280         switch (sa->state) {
281         case SFC_ADAPTER_CONFIGURED:
282                 break;
283         case SFC_ADAPTER_STARTED:
284                 sfc_info(sa, "already started");
285                 return 0;
286         default:
287                 rc = EINVAL;
288                 goto fail_bad_state;
289         }
290
291         sa->state = SFC_ADAPTER_STARTING;
292
293         sfc_log_init(sa, "set resource limits");
294         rc = sfc_set_drv_limits(sa);
295         if (rc != 0)
296                 goto fail_set_drv_limits;
297
298         sfc_log_init(sa, "init nic");
299         rc = efx_nic_init(sa->nic);
300         if (rc != 0)
301                 goto fail_nic_init;
302
303         rc = sfc_intr_start(sa);
304         if (rc != 0)
305                 goto fail_intr_start;
306
307         rc = sfc_ev_start(sa);
308         if (rc != 0)
309                 goto fail_ev_start;
310
311         rc = sfc_port_start(sa);
312         if (rc != 0)
313                 goto fail_port_start;
314
315         rc = sfc_rx_start(sa);
316         if (rc != 0)
317                 goto fail_rx_start;
318
319         rc = sfc_tx_start(sa);
320         if (rc != 0)
321                 goto fail_tx_start;
322
323         sa->state = SFC_ADAPTER_STARTED;
324         sfc_log_init(sa, "done");
325         return 0;
326
327 fail_tx_start:
328         sfc_rx_stop(sa);
329
330 fail_rx_start:
331         sfc_port_stop(sa);
332
333 fail_port_start:
334         sfc_ev_stop(sa);
335
336 fail_ev_start:
337         sfc_intr_stop(sa);
338
339 fail_intr_start:
340         efx_nic_fini(sa->nic);
341
342 fail_nic_init:
343 fail_set_drv_limits:
344         sa->state = SFC_ADAPTER_CONFIGURED;
345 fail_bad_state:
346         sfc_log_init(sa, "failed %d", rc);
347         return rc;
348 }
349
350 void
351 sfc_stop(struct sfc_adapter *sa)
352 {
353         sfc_log_init(sa, "entry");
354
355         SFC_ASSERT(sfc_adapter_is_locked(sa));
356
357         switch (sa->state) {
358         case SFC_ADAPTER_STARTED:
359                 break;
360         case SFC_ADAPTER_CONFIGURED:
361                 sfc_info(sa, "already stopped");
362                 return;
363         default:
364                 sfc_err(sa, "stop in unexpected state %u", sa->state);
365                 SFC_ASSERT(B_FALSE);
366                 return;
367         }
368
369         sa->state = SFC_ADAPTER_STOPPING;
370
371         sfc_tx_stop(sa);
372         sfc_rx_stop(sa);
373         sfc_port_stop(sa);
374         sfc_ev_stop(sa);
375         sfc_intr_stop(sa);
376         efx_nic_fini(sa->nic);
377
378         sa->state = SFC_ADAPTER_CONFIGURED;
379         sfc_log_init(sa, "done");
380 }
381
382 int
383 sfc_configure(struct sfc_adapter *sa)
384 {
385         int rc;
386
387         sfc_log_init(sa, "entry");
388
389         SFC_ASSERT(sfc_adapter_is_locked(sa));
390
391         SFC_ASSERT(sa->state == SFC_ADAPTER_INITIALIZED);
392         sa->state = SFC_ADAPTER_CONFIGURING;
393
394         rc = sfc_check_conf(sa);
395         if (rc != 0)
396                 goto fail_check_conf;
397
398         rc = sfc_intr_init(sa);
399         if (rc != 0)
400                 goto fail_intr_init;
401
402         rc = sfc_ev_init(sa);
403         if (rc != 0)
404                 goto fail_ev_init;
405
406         rc = sfc_port_init(sa);
407         if (rc != 0)
408                 goto fail_port_init;
409
410         rc = sfc_rx_init(sa);
411         if (rc != 0)
412                 goto fail_rx_init;
413
414         rc = sfc_tx_init(sa);
415         if (rc != 0)
416                 goto fail_tx_init;
417
418         sa->state = SFC_ADAPTER_CONFIGURED;
419         sfc_log_init(sa, "done");
420         return 0;
421
422 fail_tx_init:
423         sfc_rx_fini(sa);
424
425 fail_rx_init:
426         sfc_port_fini(sa);
427
428 fail_port_init:
429         sfc_ev_fini(sa);
430
431 fail_ev_init:
432         sfc_intr_fini(sa);
433
434 fail_intr_init:
435 fail_check_conf:
436         sa->state = SFC_ADAPTER_INITIALIZED;
437         sfc_log_init(sa, "failed %d", rc);
438         return rc;
439 }
440
441 void
442 sfc_close(struct sfc_adapter *sa)
443 {
444         sfc_log_init(sa, "entry");
445
446         SFC_ASSERT(sfc_adapter_is_locked(sa));
447
448         SFC_ASSERT(sa->state == SFC_ADAPTER_CONFIGURED);
449         sa->state = SFC_ADAPTER_CLOSING;
450
451         sfc_tx_fini(sa);
452         sfc_rx_fini(sa);
453         sfc_port_fini(sa);
454         sfc_ev_fini(sa);
455         sfc_intr_fini(sa);
456
457         sa->state = SFC_ADAPTER_INITIALIZED;
458         sfc_log_init(sa, "done");
459 }
460
461 static int
462 sfc_mem_bar_init(struct sfc_adapter *sa)
463 {
464         struct rte_eth_dev *eth_dev = sa->eth_dev;
465         struct rte_pci_device *pci_dev = SFC_DEV_TO_PCI(eth_dev);
466         efsys_bar_t *ebp = &sa->mem_bar;
467         unsigned int i;
468         struct rte_mem_resource *res;
469
470         for (i = 0; i < RTE_DIM(pci_dev->mem_resource); i++) {
471                 res = &pci_dev->mem_resource[i];
472                 if ((res->len != 0) && (res->phys_addr != 0)) {
473                         /* Found first memory BAR */
474                         SFC_BAR_LOCK_INIT(ebp, eth_dev->data->name);
475                         ebp->esb_rid = i;
476                         ebp->esb_dev = pci_dev;
477                         ebp->esb_base = res->addr;
478                         return 0;
479                 }
480         }
481
482         return EFAULT;
483 }
484
485 static void
486 sfc_mem_bar_fini(struct sfc_adapter *sa)
487 {
488         efsys_bar_t *ebp = &sa->mem_bar;
489
490         SFC_BAR_LOCK_DESTROY(ebp);
491         memset(ebp, 0, sizeof(*ebp));
492 }
493
494 #if EFSYS_OPT_RX_SCALE
495 /*
496  * A fixed RSS key which has a property of being symmetric
497  * (symmetrical flows are distributed to the same CPU)
498  * and also known to give a uniform distribution
499  * (a good distribution of traffic between different CPUs)
500  */
501 static const uint8_t default_rss_key[SFC_RSS_KEY_SIZE] = {
502         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
503         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
504         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
505         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
506         0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a, 0x6d, 0x5a,
507 };
508 #endif
509
510 static int
511 sfc_set_rss_defaults(struct sfc_adapter *sa)
512 {
513 #if EFSYS_OPT_RX_SCALE
514         int rc;
515
516         rc = efx_intr_init(sa->nic, sa->intr.type, NULL);
517         if (rc != 0)
518                 goto fail_intr_init;
519
520         rc = efx_ev_init(sa->nic);
521         if (rc != 0)
522                 goto fail_ev_init;
523
524         rc = efx_rx_init(sa->nic);
525         if (rc != 0)
526                 goto fail_rx_init;
527
528         rc = efx_rx_scale_support_get(sa->nic, &sa->rss_support);
529         if (rc != 0)
530                 goto fail_scale_support_get;
531
532         rc = efx_rx_hash_support_get(sa->nic, &sa->hash_support);
533         if (rc != 0)
534                 goto fail_hash_support_get;
535
536         efx_rx_fini(sa->nic);
537         efx_ev_fini(sa->nic);
538         efx_intr_fini(sa->nic);
539
540         sa->rss_hash_types = sfc_rte_to_efx_hash_type(SFC_RSS_OFFLOADS);
541
542         rte_memcpy(sa->rss_key, default_rss_key, sizeof(sa->rss_key));
543
544         return 0;
545
546 fail_hash_support_get:
547 fail_scale_support_get:
548 fail_rx_init:
549         efx_ev_fini(sa->nic);
550
551 fail_ev_init:
552         efx_intr_fini(sa->nic);
553
554 fail_intr_init:
555         return rc;
556 #else
557         return 0;
558 #endif
559 }
560
561 int
562 sfc_attach(struct sfc_adapter *sa)
563 {
564         struct rte_pci_device *pci_dev = SFC_DEV_TO_PCI(sa->eth_dev);
565         const efx_nic_cfg_t *encp;
566         efx_nic_t *enp;
567         int rc;
568
569         sfc_log_init(sa, "entry");
570
571         SFC_ASSERT(sfc_adapter_is_locked(sa));
572
573         sa->socket_id = rte_socket_id();
574
575         sfc_log_init(sa, "init mem bar");
576         rc = sfc_mem_bar_init(sa);
577         if (rc != 0)
578                 goto fail_mem_bar_init;
579
580         sfc_log_init(sa, "get family");
581         rc = efx_family(pci_dev->id.vendor_id, pci_dev->id.device_id,
582                         &sa->family);
583         if (rc != 0)
584                 goto fail_family;
585         sfc_log_init(sa, "family is %u", sa->family);
586
587         sfc_log_init(sa, "create nic");
588         rte_spinlock_init(&sa->nic_lock);
589         rc = efx_nic_create(sa->family, (efsys_identifier_t *)sa,
590                             &sa->mem_bar, &sa->nic_lock, &enp);
591         if (rc != 0)
592                 goto fail_nic_create;
593         sa->nic = enp;
594
595         rc = sfc_mcdi_init(sa);
596         if (rc != 0)
597                 goto fail_mcdi_init;
598
599         sfc_log_init(sa, "probe nic");
600         rc = efx_nic_probe(enp);
601         if (rc != 0)
602                 goto fail_nic_probe;
603
604         efx_mcdi_new_epoch(enp);
605
606         sfc_log_init(sa, "reset nic");
607         rc = efx_nic_reset(enp);
608         if (rc != 0)
609                 goto fail_nic_reset;
610
611         encp = efx_nic_cfg_get(sa->nic);
612
613         sa->tso = encp->enc_fw_assisted_tso_v2_enabled;
614         if (!sa->tso)
615                 sfc_warn(sa, "TSO support isn't available on this adapter");
616
617         sfc_log_init(sa, "estimate resource limits");
618         rc = sfc_estimate_resource_limits(sa);
619         if (rc != 0)
620                 goto fail_estimate_rsrc_limits;
621
622         sa->txq_max_entries = encp->enc_txq_max_ndescs;
623         SFC_ASSERT(rte_is_power_of_2(sa->txq_max_entries));
624
625         rc = sfc_intr_attach(sa);
626         if (rc != 0)
627                 goto fail_intr_attach;
628
629         efx_phy_adv_cap_get(sa->nic, EFX_PHY_CAP_PERM,
630                             &sa->port.phy_adv_cap_mask);
631
632         rc = sfc_set_rss_defaults(sa);
633         if (rc != 0)
634                 goto fail_set_rss_defaults;
635
636         sfc_log_init(sa, "fini nic");
637         efx_nic_fini(enp);
638
639         sa->state = SFC_ADAPTER_INITIALIZED;
640
641         sfc_log_init(sa, "done");
642         return 0;
643
644 fail_set_rss_defaults:
645         sfc_intr_detach(sa);
646
647 fail_intr_attach:
648         efx_nic_fini(sa->nic);
649
650 fail_estimate_rsrc_limits:
651 fail_nic_reset:
652         sfc_log_init(sa, "unprobe nic");
653         efx_nic_unprobe(enp);
654
655 fail_nic_probe:
656         sfc_mcdi_fini(sa);
657
658 fail_mcdi_init:
659         sfc_log_init(sa, "destroy nic");
660         sa->nic = NULL;
661         efx_nic_destroy(enp);
662
663 fail_nic_create:
664 fail_family:
665         sfc_mem_bar_fini(sa);
666
667 fail_mem_bar_init:
668         sfc_log_init(sa, "failed %d", rc);
669         return rc;
670 }
671
672 void
673 sfc_detach(struct sfc_adapter *sa)
674 {
675         efx_nic_t *enp = sa->nic;
676
677         sfc_log_init(sa, "entry");
678
679         SFC_ASSERT(sfc_adapter_is_locked(sa));
680
681         sfc_intr_detach(sa);
682
683         sfc_log_init(sa, "unprobe nic");
684         efx_nic_unprobe(enp);
685
686         sfc_mcdi_fini(sa);
687
688         sfc_log_init(sa, "destroy nic");
689         sa->nic = NULL;
690         efx_nic_destroy(enp);
691
692         sfc_mem_bar_fini(sa);
693
694         sa->state = SFC_ADAPTER_UNINITIALIZED;
695 }