ethdev: add return value to stats get dev op
[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 void 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
391 static int enicpmd_dev_configure(struct rte_eth_dev *eth_dev)
392 {
393         int ret;
394         struct enic *enic = pmd_priv(eth_dev);
395
396         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
397                 return -E_RTE_SECONDARY;
398
399         ENICPMD_FUNC_TRACE();
400         ret = enic_set_vnic_res(enic);
401         if (ret) {
402                 dev_err(enic, "Set vNIC resource num  failed, aborting\n");
403                 return ret;
404         }
405
406         if (eth_dev->data->dev_conf.rxmode.split_hdr_size &&
407                 eth_dev->data->dev_conf.rxmode.header_split) {
408                 /* Enable header-data-split */
409                 enic_set_hdr_split_size(enic,
410                         eth_dev->data->dev_conf.rxmode.split_hdr_size);
411         }
412
413         enicpmd_vlan_offload_set(eth_dev, ETH_VLAN_STRIP_MASK);
414         enic->hw_ip_checksum = eth_dev->data->dev_conf.rxmode.hw_ip_checksum;
415         return 0;
416 }
417
418 /* Start the device.
419  * It returns 0 on success.
420  */
421 static int enicpmd_dev_start(struct rte_eth_dev *eth_dev)
422 {
423         struct enic *enic = pmd_priv(eth_dev);
424
425         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
426                 return -E_RTE_SECONDARY;
427
428         ENICPMD_FUNC_TRACE();
429         return enic_enable(enic);
430 }
431
432 /*
433  * Stop device: disable rx and tx functions to allow for reconfiguring.
434  */
435 static void enicpmd_dev_stop(struct rte_eth_dev *eth_dev)
436 {
437         struct rte_eth_link link;
438         struct enic *enic = pmd_priv(eth_dev);
439
440         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
441                 return;
442
443         ENICPMD_FUNC_TRACE();
444         enic_disable(enic);
445         memset(&link, 0, sizeof(link));
446         rte_atomic64_cmpset((uint64_t *)&eth_dev->data->dev_link,
447                 *(uint64_t *)&eth_dev->data->dev_link,
448                 *(uint64_t *)&link);
449 }
450
451 /*
452  * Stop device.
453  */
454 static void enicpmd_dev_close(struct rte_eth_dev *eth_dev)
455 {
456         struct enic *enic = pmd_priv(eth_dev);
457
458         ENICPMD_FUNC_TRACE();
459         enic_remove(enic);
460 }
461
462 static int enicpmd_dev_link_update(struct rte_eth_dev *eth_dev,
463         __rte_unused int wait_to_complete)
464 {
465         struct enic *enic = pmd_priv(eth_dev);
466
467         ENICPMD_FUNC_TRACE();
468         return enic_link_update(enic);
469 }
470
471 static int enicpmd_dev_stats_get(struct rte_eth_dev *eth_dev,
472         struct rte_eth_stats *stats)
473 {
474         struct enic *enic = pmd_priv(eth_dev);
475
476         ENICPMD_FUNC_TRACE();
477         return enic_dev_stats_get(enic, stats);
478 }
479
480 static void enicpmd_dev_stats_reset(struct rte_eth_dev *eth_dev)
481 {
482         struct enic *enic = pmd_priv(eth_dev);
483
484         ENICPMD_FUNC_TRACE();
485         enic_dev_stats_clear(enic);
486 }
487
488 static void enicpmd_dev_info_get(struct rte_eth_dev *eth_dev,
489         struct rte_eth_dev_info *device_info)
490 {
491         struct enic *enic = pmd_priv(eth_dev);
492
493         ENICPMD_FUNC_TRACE();
494         device_info->pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
495         /* Scattered Rx uses two receive queues per rx queue exposed to dpdk */
496         device_info->max_rx_queues = enic->conf_rq_count / 2;
497         device_info->max_tx_queues = enic->conf_wq_count;
498         device_info->min_rx_bufsize = ENIC_MIN_MTU;
499         device_info->max_rx_pktlen = enic->max_mtu + ETHER_HDR_LEN + 4;
500         device_info->max_mac_addrs = ENIC_MAX_MAC_ADDR;
501         device_info->rx_offload_capa =
502                 DEV_RX_OFFLOAD_VLAN_STRIP |
503                 DEV_RX_OFFLOAD_IPV4_CKSUM |
504                 DEV_RX_OFFLOAD_UDP_CKSUM  |
505                 DEV_RX_OFFLOAD_TCP_CKSUM;
506         device_info->tx_offload_capa =
507                 DEV_TX_OFFLOAD_VLAN_INSERT |
508                 DEV_TX_OFFLOAD_IPV4_CKSUM  |
509                 DEV_TX_OFFLOAD_UDP_CKSUM   |
510                 DEV_TX_OFFLOAD_TCP_CKSUM   |
511                 DEV_TX_OFFLOAD_TCP_TSO;
512         device_info->default_rxconf = (struct rte_eth_rxconf) {
513                 .rx_free_thresh = ENIC_DEFAULT_RX_FREE_THRESH
514         };
515 }
516
517 static const uint32_t *enicpmd_dev_supported_ptypes_get(struct rte_eth_dev *dev)
518 {
519         static const uint32_t ptypes[] = {
520                 RTE_PTYPE_L2_ETHER,
521                 RTE_PTYPE_L2_ETHER_VLAN,
522                 RTE_PTYPE_L3_IPV4_EXT_UNKNOWN,
523                 RTE_PTYPE_L3_IPV6_EXT_UNKNOWN,
524                 RTE_PTYPE_L4_TCP,
525                 RTE_PTYPE_L4_UDP,
526                 RTE_PTYPE_L4_FRAG,
527                 RTE_PTYPE_L4_NONFRAG,
528                 RTE_PTYPE_UNKNOWN
529         };
530
531         if (dev->rx_pkt_burst == enic_recv_pkts)
532                 return ptypes;
533         return NULL;
534 }
535
536 static void enicpmd_dev_promiscuous_enable(struct rte_eth_dev *eth_dev)
537 {
538         struct enic *enic = pmd_priv(eth_dev);
539
540         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
541                 return;
542
543         ENICPMD_FUNC_TRACE();
544
545         enic->promisc = 1;
546         enic_add_packet_filter(enic);
547 }
548
549 static void enicpmd_dev_promiscuous_disable(struct rte_eth_dev *eth_dev)
550 {
551         struct enic *enic = pmd_priv(eth_dev);
552
553         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
554                 return;
555
556         ENICPMD_FUNC_TRACE();
557         enic->promisc = 0;
558         enic_add_packet_filter(enic);
559 }
560
561 static void enicpmd_dev_allmulticast_enable(struct rte_eth_dev *eth_dev)
562 {
563         struct enic *enic = pmd_priv(eth_dev);
564
565         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
566                 return;
567
568         ENICPMD_FUNC_TRACE();
569         enic->allmulti = 1;
570         enic_add_packet_filter(enic);
571 }
572
573 static void enicpmd_dev_allmulticast_disable(struct rte_eth_dev *eth_dev)
574 {
575         struct enic *enic = pmd_priv(eth_dev);
576
577         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
578                 return;
579
580         ENICPMD_FUNC_TRACE();
581         enic->allmulti = 0;
582         enic_add_packet_filter(enic);
583 }
584
585 static int enicpmd_add_mac_addr(struct rte_eth_dev *eth_dev,
586         struct ether_addr *mac_addr,
587         __rte_unused uint32_t index, __rte_unused uint32_t pool)
588 {
589         struct enic *enic = pmd_priv(eth_dev);
590
591         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
592                 return -E_RTE_SECONDARY;
593
594         ENICPMD_FUNC_TRACE();
595         return enic_set_mac_address(enic, mac_addr->addr_bytes);
596 }
597
598 static void enicpmd_remove_mac_addr(struct rte_eth_dev *eth_dev, uint32_t index)
599 {
600         struct enic *enic = pmd_priv(eth_dev);
601
602         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
603                 return;
604
605         ENICPMD_FUNC_TRACE();
606         enic_del_mac_address(enic, index);
607 }
608
609 static int enicpmd_mtu_set(struct rte_eth_dev *eth_dev, uint16_t mtu)
610 {
611         struct enic *enic = pmd_priv(eth_dev);
612
613         ENICPMD_FUNC_TRACE();
614         return enic_set_mtu(enic, mtu);
615 }
616
617 static const struct eth_dev_ops enicpmd_eth_dev_ops = {
618         .dev_configure        = enicpmd_dev_configure,
619         .dev_start            = enicpmd_dev_start,
620         .dev_stop             = enicpmd_dev_stop,
621         .dev_set_link_up      = NULL,
622         .dev_set_link_down    = NULL,
623         .dev_close            = enicpmd_dev_close,
624         .promiscuous_enable   = enicpmd_dev_promiscuous_enable,
625         .promiscuous_disable  = enicpmd_dev_promiscuous_disable,
626         .allmulticast_enable  = enicpmd_dev_allmulticast_enable,
627         .allmulticast_disable = enicpmd_dev_allmulticast_disable,
628         .link_update          = enicpmd_dev_link_update,
629         .stats_get            = enicpmd_dev_stats_get,
630         .stats_reset          = enicpmd_dev_stats_reset,
631         .queue_stats_mapping_set = NULL,
632         .dev_infos_get        = enicpmd_dev_info_get,
633         .dev_supported_ptypes_get = enicpmd_dev_supported_ptypes_get,
634         .mtu_set              = enicpmd_mtu_set,
635         .vlan_filter_set      = enicpmd_vlan_filter_set,
636         .vlan_tpid_set        = NULL,
637         .vlan_offload_set     = enicpmd_vlan_offload_set,
638         .vlan_strip_queue_set = NULL,
639         .rx_queue_start       = enicpmd_dev_rx_queue_start,
640         .rx_queue_stop        = enicpmd_dev_rx_queue_stop,
641         .tx_queue_start       = enicpmd_dev_tx_queue_start,
642         .tx_queue_stop        = enicpmd_dev_tx_queue_stop,
643         .rx_queue_setup       = enicpmd_dev_rx_queue_setup,
644         .rx_queue_release     = enicpmd_dev_rx_queue_release,
645         .rx_queue_count       = enicpmd_dev_rx_queue_count,
646         .rx_descriptor_done   = NULL,
647         .tx_queue_setup       = enicpmd_dev_tx_queue_setup,
648         .tx_queue_release     = enicpmd_dev_tx_queue_release,
649         .dev_led_on           = NULL,
650         .dev_led_off          = NULL,
651         .flow_ctrl_get        = NULL,
652         .flow_ctrl_set        = NULL,
653         .priority_flow_ctrl_set = NULL,
654         .mac_addr_add         = enicpmd_add_mac_addr,
655         .mac_addr_remove      = enicpmd_remove_mac_addr,
656         .filter_ctrl          = enicpmd_dev_filter_ctrl,
657 };
658
659 struct enic *enicpmd_list_head = NULL;
660 /* Initialize the driver
661  * It returns 0 on success.
662  */
663 static int eth_enicpmd_dev_init(struct rte_eth_dev *eth_dev)
664 {
665         struct rte_pci_device *pdev;
666         struct rte_pci_addr *addr;
667         struct enic *enic = pmd_priv(eth_dev);
668
669         ENICPMD_FUNC_TRACE();
670
671         enic->port_id = eth_dev->data->port_id;
672         enic->rte_dev = eth_dev;
673         eth_dev->dev_ops = &enicpmd_eth_dev_ops;
674         eth_dev->rx_pkt_burst = &enic_recv_pkts;
675         eth_dev->tx_pkt_burst = &enic_xmit_pkts;
676
677         pdev = RTE_ETH_DEV_TO_PCI(eth_dev);
678         rte_eth_copy_pci_info(eth_dev, pdev);
679         enic->pdev = pdev;
680         addr = &pdev->addr;
681
682         snprintf(enic->bdf_name, ENICPMD_BDF_LENGTH, "%04x:%02x:%02x.%x",
683                 addr->domain, addr->bus, addr->devid, addr->function);
684
685         return enic_probe(enic);
686 }
687
688 static int eth_enic_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
689         struct rte_pci_device *pci_dev)
690 {
691         return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct enic),
692                 eth_enicpmd_dev_init);
693 }
694
695 static int eth_enic_pci_remove(struct rte_pci_device *pci_dev)
696 {
697         return rte_eth_dev_pci_generic_remove(pci_dev, NULL);
698 }
699
700 static struct rte_pci_driver rte_enic_pmd = {
701         .id_table = pci_id_enic_map,
702         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC,
703         .probe = eth_enic_pci_probe,
704         .remove = eth_enic_pci_remove,
705 };
706
707 RTE_PMD_REGISTER_PCI(net_enic, rte_enic_pmd);
708 RTE_PMD_REGISTER_PCI_TABLE(net_enic, pci_id_enic_map);
709 RTE_PMD_REGISTER_KMOD_DEP(net_enic, "* igb_uio | uio_pci_generic | vfio-pci");