c02f9b7b3f3385994c110fc805e250c2c46be2f3
[dpdk.git] / drivers / net / enic / enic_ethdev.c
1 /*
2  * Copyright 2008-2014 Cisco Systems, Inc.  All rights reserved.
3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
4  *
5  * Copyright (c) 2014, Cisco Systems, Inc.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  */
34
35 #include <stdio.h>
36 #include <stdint.h>
37
38 #include <rte_dev.h>
39 #include <rte_pci.h>
40 #include <rte_ethdev.h>
41 #include <rte_ethdev_pci.h>
42 #include <rte_string_fns.h>
43
44 #include "vnic_intr.h"
45 #include "vnic_cq.h"
46 #include "vnic_wq.h"
47 #include "vnic_rq.h"
48 #include "vnic_enet.h"
49 #include "enic.h"
50
51 #ifdef RTE_LIBRTE_ENIC_DEBUG
52 #define ENICPMD_FUNC_TRACE() \
53         RTE_LOG(DEBUG, PMD, "ENICPMD trace: %s\n", __func__)
54 #else
55 #define ENICPMD_FUNC_TRACE() (void)0
56 #endif
57
58 /*
59  * The set of PCI devices this driver supports
60  */
61 #define CISCO_PCI_VENDOR_ID 0x1137
62 static const struct rte_pci_id pci_id_enic_map[] = {
63         { RTE_PCI_DEVICE(CISCO_PCI_VENDOR_ID, PCI_DEVICE_ID_CISCO_VIC_ENET) },
64         { RTE_PCI_DEVICE(CISCO_PCI_VENDOR_ID, PCI_DEVICE_ID_CISCO_VIC_ENET_VF) },
65         {.vendor_id = 0, /* sentinel */},
66 };
67
68 static int
69 enicpmd_fdir_ctrl_func(struct rte_eth_dev *eth_dev,
70                         enum rte_filter_op filter_op, void *arg)
71 {
72         struct enic *enic = pmd_priv(eth_dev);
73         int ret = 0;
74
75         ENICPMD_FUNC_TRACE();
76         if (filter_op == RTE_ETH_FILTER_NOP)
77                 return 0;
78
79         if (arg == NULL && filter_op != RTE_ETH_FILTER_FLUSH)
80                 return -EINVAL;
81
82         switch (filter_op) {
83         case RTE_ETH_FILTER_ADD:
84         case RTE_ETH_FILTER_UPDATE:
85                 ret = enic_fdir_add_fltr(enic,
86                         (struct rte_eth_fdir_filter *)arg);
87                 break;
88
89         case RTE_ETH_FILTER_DELETE:
90                 ret = enic_fdir_del_fltr(enic,
91                         (struct rte_eth_fdir_filter *)arg);
92                 break;
93
94         case RTE_ETH_FILTER_STATS:
95                 enic_fdir_stats_get(enic, (struct rte_eth_fdir_stats *)arg);
96                 break;
97
98         case RTE_ETH_FILTER_FLUSH:
99                 dev_warning(enic, "unsupported operation %u", filter_op);
100                 ret = -ENOTSUP;
101                 break;
102         case RTE_ETH_FILTER_INFO:
103                 enic_fdir_info_get(enic, (struct rte_eth_fdir_info *)arg);
104                 break;
105         default:
106                 dev_err(enic, "unknown operation %u", filter_op);
107                 ret = -EINVAL;
108                 break;
109         }
110         return ret;
111 }
112
113 static int
114 enicpmd_dev_filter_ctrl(struct rte_eth_dev *dev,
115                      enum rte_filter_type filter_type,
116                      enum rte_filter_op filter_op,
117                      void *arg)
118 {
119         int ret = 0;
120
121         ENICPMD_FUNC_TRACE();
122
123         switch (filter_type) {
124         case RTE_ETH_FILTER_GENERIC:
125                 if (filter_op != RTE_ETH_FILTER_GET)
126                         return -EINVAL;
127                 *(const void **)arg = &enic_flow_ops;
128                 break;
129         case RTE_ETH_FILTER_FDIR:
130                 ret = enicpmd_fdir_ctrl_func(dev, filter_op, arg);
131                 break;
132         default:
133                 dev_warning(enic, "Filter type (%d) not supported",
134                         filter_type);
135                 ret = -EINVAL;
136                 break;
137         }
138
139         return ret;
140 }
141
142 static void enicpmd_dev_tx_queue_release(void *txq)
143 {
144         ENICPMD_FUNC_TRACE();
145
146         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
147                 return;
148
149         enic_free_wq(txq);
150 }
151
152 static int enicpmd_dev_setup_intr(struct enic *enic)
153 {
154         int ret;
155         unsigned int index;
156
157         ENICPMD_FUNC_TRACE();
158
159         /* Are we done with the init of all the queues? */
160         for (index = 0; index < enic->cq_count; index++) {
161                 if (!enic->cq[index].ctrl)
162                         break;
163         }
164         if (enic->cq_count != index)
165                 return 0;
166         for (index = 0; index < enic->wq_count; index++) {
167                 if (!enic->wq[index].ctrl)
168                         break;
169         }
170         if (enic->wq_count != index)
171                 return 0;
172         /* check start of packet (SOP) RQs only in case scatter is disabled. */
173         for (index = 0; index < enic->rq_count; index++) {
174                 if (!enic->rq[enic_rte_rq_idx_to_sop_idx(index)].ctrl)
175                         break;
176         }
177         if (enic->rq_count != index)
178                 return 0;
179
180         ret = enic_alloc_intr_resources(enic);
181         if (ret) {
182                 dev_err(enic, "alloc intr failed\n");
183                 return ret;
184         }
185         enic_init_vnic_resources(enic);
186
187         ret = enic_setup_finish(enic);
188         if (ret)
189                 dev_err(enic, "setup could not be finished\n");
190
191         return ret;
192 }
193
194 static int enicpmd_dev_tx_queue_setup(struct rte_eth_dev *eth_dev,
195         uint16_t queue_idx,
196         uint16_t nb_desc,
197         unsigned int socket_id,
198         __rte_unused const struct rte_eth_txconf *tx_conf)
199 {
200         int ret;
201         struct enic *enic = pmd_priv(eth_dev);
202
203         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
204                 return -E_RTE_SECONDARY;
205
206         ENICPMD_FUNC_TRACE();
207         if (queue_idx >= ENIC_WQ_MAX) {
208                 dev_err(enic,
209                         "Max number of TX queues exceeded.  Max is %d\n",
210                         ENIC_WQ_MAX);
211                 return -EINVAL;
212         }
213
214         eth_dev->data->tx_queues[queue_idx] = (void *)&enic->wq[queue_idx];
215
216         ret = enic_alloc_wq(enic, queue_idx, socket_id, nb_desc);
217         if (ret) {
218                 dev_err(enic, "error in allocating wq\n");
219                 return ret;
220         }
221
222         return enicpmd_dev_setup_intr(enic);
223 }
224
225 static int enicpmd_dev_tx_queue_start(struct rte_eth_dev *eth_dev,
226         uint16_t queue_idx)
227 {
228         struct enic *enic = pmd_priv(eth_dev);
229
230         ENICPMD_FUNC_TRACE();
231
232         enic_start_wq(enic, queue_idx);
233
234         return 0;
235 }
236
237 static int enicpmd_dev_tx_queue_stop(struct rte_eth_dev *eth_dev,
238         uint16_t queue_idx)
239 {
240         int ret;
241         struct enic *enic = pmd_priv(eth_dev);
242
243         ENICPMD_FUNC_TRACE();
244
245         ret = enic_stop_wq(enic, queue_idx);
246         if (ret)
247                 dev_err(enic, "error in stopping wq %d\n", queue_idx);
248
249         return ret;
250 }
251
252 static int enicpmd_dev_rx_queue_start(struct rte_eth_dev *eth_dev,
253         uint16_t queue_idx)
254 {
255         struct enic *enic = pmd_priv(eth_dev);
256
257         ENICPMD_FUNC_TRACE();
258
259         enic_start_rq(enic, queue_idx);
260
261         return 0;
262 }
263
264 static int enicpmd_dev_rx_queue_stop(struct rte_eth_dev *eth_dev,
265         uint16_t queue_idx)
266 {
267         int ret;
268         struct enic *enic = pmd_priv(eth_dev);
269
270         ENICPMD_FUNC_TRACE();
271
272         ret = enic_stop_rq(enic, queue_idx);
273         if (ret)
274                 dev_err(enic, "error in stopping rq %d\n", queue_idx);
275
276         return ret;
277 }
278
279 static void enicpmd_dev_rx_queue_release(void *rxq)
280 {
281         ENICPMD_FUNC_TRACE();
282
283         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
284                 return;
285
286         enic_free_rq(rxq);
287 }
288
289 static uint32_t enicpmd_dev_rx_queue_count(struct rte_eth_dev *dev,
290                                            uint16_t rx_queue_id)
291 {
292         struct enic *enic = pmd_priv(dev);
293         uint32_t queue_count = 0;
294         struct vnic_cq *cq;
295         uint32_t cq_tail;
296         uint16_t cq_idx;
297         int rq_num;
298
299         rq_num = enic_rte_rq_idx_to_sop_idx(rx_queue_id);
300         cq = &enic->cq[enic_cq_rq(enic, rq_num)];
301         cq_idx = cq->to_clean;
302
303         cq_tail = ioread32(&cq->ctrl->cq_tail);
304
305         if (cq_tail < cq_idx)
306                 cq_tail += cq->ring.desc_count;
307
308         queue_count = cq_tail - cq_idx;
309
310         return queue_count;
311 }
312
313 static int enicpmd_dev_rx_queue_setup(struct rte_eth_dev *eth_dev,
314         uint16_t queue_idx,
315         uint16_t nb_desc,
316         unsigned int socket_id,
317         const struct rte_eth_rxconf *rx_conf,
318         struct rte_mempool *mp)
319 {
320         int ret;
321         struct enic *enic = pmd_priv(eth_dev);
322
323         ENICPMD_FUNC_TRACE();
324
325         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
326                 return -E_RTE_SECONDARY;
327
328         /* With Rx scatter support, two RQs are now used on VIC per RQ used
329          * by the application.
330          */
331         if (queue_idx * 2 >= ENIC_RQ_MAX) {
332                 dev_err(enic,
333                         "Max number of RX queues exceeded.  Max is %d. This PMD uses 2 RQs on VIC per RQ used by DPDK.\n",
334                         ENIC_RQ_MAX);
335                 return -EINVAL;
336         }
337
338         eth_dev->data->rx_queues[queue_idx] =
339                 (void *)&enic->rq[enic_rte_rq_idx_to_sop_idx(queue_idx)];
340
341         ret = enic_alloc_rq(enic, queue_idx, socket_id, mp, nb_desc,
342                             rx_conf->rx_free_thresh);
343         if (ret) {
344                 dev_err(enic, "error in allocating rq\n");
345                 return ret;
346         }
347
348         return enicpmd_dev_setup_intr(enic);
349 }
350
351 static int enicpmd_vlan_filter_set(struct rte_eth_dev *eth_dev,
352         uint16_t vlan_id, int on)
353 {
354         struct enic *enic = pmd_priv(eth_dev);
355         int err;
356
357         ENICPMD_FUNC_TRACE();
358         if (on)
359                 err = enic_add_vlan(enic, vlan_id);
360         else
361                 err = enic_del_vlan(enic, vlan_id);
362         return err;
363 }
364
365 static int enicpmd_vlan_offload_set(struct rte_eth_dev *eth_dev, int mask)
366 {
367         struct enic *enic = pmd_priv(eth_dev);
368
369         ENICPMD_FUNC_TRACE();
370
371         if (mask & ETH_VLAN_STRIP_MASK) {
372                 if (eth_dev->data->dev_conf.rxmode.hw_vlan_strip)
373                         enic->ig_vlan_strip_en = 1;
374                 else
375                         enic->ig_vlan_strip_en = 0;
376         }
377         enic_set_rss_nic_cfg(enic);
378
379
380         if (mask & ETH_VLAN_FILTER_MASK) {
381                 dev_warning(enic,
382                         "Configuration of VLAN filter is not supported\n");
383         }
384
385         if (mask & ETH_VLAN_EXTEND_MASK) {
386                 dev_warning(enic,
387                         "Configuration of extended VLAN is not supported\n");
388         }
389
390         return 0;
391 }
392
393 static int enicpmd_dev_configure(struct rte_eth_dev *eth_dev)
394 {
395         int ret;
396         struct enic *enic = pmd_priv(eth_dev);
397
398         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
399                 return -E_RTE_SECONDARY;
400
401         ENICPMD_FUNC_TRACE();
402         ret = enic_set_vnic_res(enic);
403         if (ret) {
404                 dev_err(enic, "Set vNIC resource num  failed, aborting\n");
405                 return ret;
406         }
407
408         if (eth_dev->data->dev_conf.rxmode.split_hdr_size &&
409                 eth_dev->data->dev_conf.rxmode.header_split) {
410                 /* Enable header-data-split */
411                 enic_set_hdr_split_size(enic,
412                         eth_dev->data->dev_conf.rxmode.split_hdr_size);
413         }
414
415         enic->hw_ip_checksum = eth_dev->data->dev_conf.rxmode.hw_ip_checksum;
416         ret = enicpmd_vlan_offload_set(eth_dev, ETH_VLAN_STRIP_MASK);
417
418         return ret;
419 }
420
421 /* Start the device.
422  * It returns 0 on success.
423  */
424 static int enicpmd_dev_start(struct rte_eth_dev *eth_dev)
425 {
426         struct enic *enic = pmd_priv(eth_dev);
427
428         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
429                 return -E_RTE_SECONDARY;
430
431         ENICPMD_FUNC_TRACE();
432         return enic_enable(enic);
433 }
434
435 /*
436  * Stop device: disable rx and tx functions to allow for reconfiguring.
437  */
438 static void enicpmd_dev_stop(struct rte_eth_dev *eth_dev)
439 {
440         struct rte_eth_link link;
441         struct enic *enic = pmd_priv(eth_dev);
442
443         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
444                 return;
445
446         ENICPMD_FUNC_TRACE();
447         enic_disable(enic);
448         memset(&link, 0, sizeof(link));
449         rte_atomic64_cmpset((uint64_t *)&eth_dev->data->dev_link,
450                 *(uint64_t *)&eth_dev->data->dev_link,
451                 *(uint64_t *)&link);
452 }
453
454 /*
455  * Stop device.
456  */
457 static void enicpmd_dev_close(struct rte_eth_dev *eth_dev)
458 {
459         struct enic *enic = pmd_priv(eth_dev);
460
461         ENICPMD_FUNC_TRACE();
462         enic_remove(enic);
463 }
464
465 static int enicpmd_dev_link_update(struct rte_eth_dev *eth_dev,
466         __rte_unused int wait_to_complete)
467 {
468         struct enic *enic = pmd_priv(eth_dev);
469
470         ENICPMD_FUNC_TRACE();
471         return enic_link_update(enic);
472 }
473
474 static int enicpmd_dev_stats_get(struct rte_eth_dev *eth_dev,
475         struct rte_eth_stats *stats)
476 {
477         struct enic *enic = pmd_priv(eth_dev);
478
479         ENICPMD_FUNC_TRACE();
480         return enic_dev_stats_get(enic, stats);
481 }
482
483 static void enicpmd_dev_stats_reset(struct rte_eth_dev *eth_dev)
484 {
485         struct enic *enic = pmd_priv(eth_dev);
486
487         ENICPMD_FUNC_TRACE();
488         enic_dev_stats_clear(enic);
489 }
490
491 static void enicpmd_dev_info_get(struct rte_eth_dev *eth_dev,
492         struct rte_eth_dev_info *device_info)
493 {
494         struct enic *enic = pmd_priv(eth_dev);
495
496         ENICPMD_FUNC_TRACE();
497         device_info->pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
498         /* Scattered Rx uses two receive queues per rx queue exposed to dpdk */
499         device_info->max_rx_queues = enic->conf_rq_count / 2;
500         device_info->max_tx_queues = enic->conf_wq_count;
501         device_info->min_rx_bufsize = ENIC_MIN_MTU;
502         device_info->max_rx_pktlen = enic->max_mtu + ETHER_HDR_LEN + 4;
503         device_info->max_mac_addrs = ENIC_MAX_MAC_ADDR;
504         device_info->rx_offload_capa =
505                 DEV_RX_OFFLOAD_VLAN_STRIP |
506                 DEV_RX_OFFLOAD_IPV4_CKSUM |
507                 DEV_RX_OFFLOAD_UDP_CKSUM  |
508                 DEV_RX_OFFLOAD_TCP_CKSUM;
509         device_info->tx_offload_capa =
510                 DEV_TX_OFFLOAD_VLAN_INSERT |
511                 DEV_TX_OFFLOAD_IPV4_CKSUM  |
512                 DEV_TX_OFFLOAD_UDP_CKSUM   |
513                 DEV_TX_OFFLOAD_TCP_CKSUM   |
514                 DEV_TX_OFFLOAD_TCP_TSO;
515         device_info->default_rxconf = (struct rte_eth_rxconf) {
516                 .rx_free_thresh = ENIC_DEFAULT_RX_FREE_THRESH
517         };
518 }
519
520 static const uint32_t *enicpmd_dev_supported_ptypes_get(struct rte_eth_dev *dev)
521 {
522         static const uint32_t ptypes[] = {
523                 RTE_PTYPE_L2_ETHER,
524                 RTE_PTYPE_L2_ETHER_VLAN,
525                 RTE_PTYPE_L3_IPV4_EXT_UNKNOWN,
526                 RTE_PTYPE_L3_IPV6_EXT_UNKNOWN,
527                 RTE_PTYPE_L4_TCP,
528                 RTE_PTYPE_L4_UDP,
529                 RTE_PTYPE_L4_FRAG,
530                 RTE_PTYPE_L4_NONFRAG,
531                 RTE_PTYPE_UNKNOWN
532         };
533
534         if (dev->rx_pkt_burst == enic_recv_pkts)
535                 return ptypes;
536         return NULL;
537 }
538
539 static void enicpmd_dev_promiscuous_enable(struct rte_eth_dev *eth_dev)
540 {
541         struct enic *enic = pmd_priv(eth_dev);
542
543         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
544                 return;
545
546         ENICPMD_FUNC_TRACE();
547
548         enic->promisc = 1;
549         enic_add_packet_filter(enic);
550 }
551
552 static void enicpmd_dev_promiscuous_disable(struct rte_eth_dev *eth_dev)
553 {
554         struct enic *enic = pmd_priv(eth_dev);
555
556         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
557                 return;
558
559         ENICPMD_FUNC_TRACE();
560         enic->promisc = 0;
561         enic_add_packet_filter(enic);
562 }
563
564 static void enicpmd_dev_allmulticast_enable(struct rte_eth_dev *eth_dev)
565 {
566         struct enic *enic = pmd_priv(eth_dev);
567
568         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
569                 return;
570
571         ENICPMD_FUNC_TRACE();
572         enic->allmulti = 1;
573         enic_add_packet_filter(enic);
574 }
575
576 static void enicpmd_dev_allmulticast_disable(struct rte_eth_dev *eth_dev)
577 {
578         struct enic *enic = pmd_priv(eth_dev);
579
580         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
581                 return;
582
583         ENICPMD_FUNC_TRACE();
584         enic->allmulti = 0;
585         enic_add_packet_filter(enic);
586 }
587
588 static int enicpmd_add_mac_addr(struct rte_eth_dev *eth_dev,
589         struct ether_addr *mac_addr,
590         __rte_unused uint32_t index, __rte_unused uint32_t pool)
591 {
592         struct enic *enic = pmd_priv(eth_dev);
593
594         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
595                 return -E_RTE_SECONDARY;
596
597         ENICPMD_FUNC_TRACE();
598         return enic_set_mac_address(enic, mac_addr->addr_bytes);
599 }
600
601 static void enicpmd_remove_mac_addr(struct rte_eth_dev *eth_dev, uint32_t index)
602 {
603         struct enic *enic = pmd_priv(eth_dev);
604
605         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
606                 return;
607
608         ENICPMD_FUNC_TRACE();
609         enic_del_mac_address(enic, index);
610 }
611
612 static int enicpmd_mtu_set(struct rte_eth_dev *eth_dev, uint16_t mtu)
613 {
614         struct enic *enic = pmd_priv(eth_dev);
615
616         ENICPMD_FUNC_TRACE();
617         return enic_set_mtu(enic, mtu);
618 }
619
620 static const struct eth_dev_ops enicpmd_eth_dev_ops = {
621         .dev_configure        = enicpmd_dev_configure,
622         .dev_start            = enicpmd_dev_start,
623         .dev_stop             = enicpmd_dev_stop,
624         .dev_set_link_up      = NULL,
625         .dev_set_link_down    = NULL,
626         .dev_close            = enicpmd_dev_close,
627         .promiscuous_enable   = enicpmd_dev_promiscuous_enable,
628         .promiscuous_disable  = enicpmd_dev_promiscuous_disable,
629         .allmulticast_enable  = enicpmd_dev_allmulticast_enable,
630         .allmulticast_disable = enicpmd_dev_allmulticast_disable,
631         .link_update          = enicpmd_dev_link_update,
632         .stats_get            = enicpmd_dev_stats_get,
633         .stats_reset          = enicpmd_dev_stats_reset,
634         .queue_stats_mapping_set = NULL,
635         .dev_infos_get        = enicpmd_dev_info_get,
636         .dev_supported_ptypes_get = enicpmd_dev_supported_ptypes_get,
637         .mtu_set              = enicpmd_mtu_set,
638         .vlan_filter_set      = enicpmd_vlan_filter_set,
639         .vlan_tpid_set        = NULL,
640         .vlan_offload_set     = enicpmd_vlan_offload_set,
641         .vlan_strip_queue_set = NULL,
642         .rx_queue_start       = enicpmd_dev_rx_queue_start,
643         .rx_queue_stop        = enicpmd_dev_rx_queue_stop,
644         .tx_queue_start       = enicpmd_dev_tx_queue_start,
645         .tx_queue_stop        = enicpmd_dev_tx_queue_stop,
646         .rx_queue_setup       = enicpmd_dev_rx_queue_setup,
647         .rx_queue_release     = enicpmd_dev_rx_queue_release,
648         .rx_queue_count       = enicpmd_dev_rx_queue_count,
649         .rx_descriptor_done   = NULL,
650         .tx_queue_setup       = enicpmd_dev_tx_queue_setup,
651         .tx_queue_release     = enicpmd_dev_tx_queue_release,
652         .dev_led_on           = NULL,
653         .dev_led_off          = NULL,
654         .flow_ctrl_get        = NULL,
655         .flow_ctrl_set        = NULL,
656         .priority_flow_ctrl_set = NULL,
657         .mac_addr_add         = enicpmd_add_mac_addr,
658         .mac_addr_remove      = enicpmd_remove_mac_addr,
659         .filter_ctrl          = enicpmd_dev_filter_ctrl,
660 };
661
662 struct enic *enicpmd_list_head = NULL;
663 /* Initialize the driver
664  * It returns 0 on success.
665  */
666 static int eth_enicpmd_dev_init(struct rte_eth_dev *eth_dev)
667 {
668         struct rte_pci_device *pdev;
669         struct rte_pci_addr *addr;
670         struct enic *enic = pmd_priv(eth_dev);
671
672         ENICPMD_FUNC_TRACE();
673
674         enic->port_id = eth_dev->data->port_id;
675         enic->rte_dev = eth_dev;
676         eth_dev->dev_ops = &enicpmd_eth_dev_ops;
677         eth_dev->rx_pkt_burst = &enic_recv_pkts;
678         eth_dev->tx_pkt_burst = &enic_xmit_pkts;
679
680         pdev = RTE_ETH_DEV_TO_PCI(eth_dev);
681         rte_eth_copy_pci_info(eth_dev, pdev);
682         enic->pdev = pdev;
683         addr = &pdev->addr;
684
685         snprintf(enic->bdf_name, ENICPMD_BDF_LENGTH, "%04x:%02x:%02x.%x",
686                 addr->domain, addr->bus, addr->devid, addr->function);
687
688         return enic_probe(enic);
689 }
690
691 static int eth_enic_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
692         struct rte_pci_device *pci_dev)
693 {
694         return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct enic),
695                 eth_enicpmd_dev_init);
696 }
697
698 static int eth_enic_pci_remove(struct rte_pci_device *pci_dev)
699 {
700         return rte_eth_dev_pci_generic_remove(pci_dev, NULL);
701 }
702
703 static struct rte_pci_driver rte_enic_pmd = {
704         .id_table = pci_id_enic_map,
705         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC,
706         .probe = eth_enic_pci_probe,
707         .remove = eth_enic_pci_remove,
708 };
709
710 RTE_PMD_REGISTER_PCI(net_enic, rte_enic_pmd);
711 RTE_PMD_REGISTER_PCI_TABLE(net_enic, pci_id_enic_map);
712 RTE_PMD_REGISTER_KMOD_DEP(net_enic, "* igb_uio | uio_pci_generic | vfio-pci");