2 * Copyright 2008-2014 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
5 * Copyright (c) 2014, Cisco Systems, Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
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
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.
43 #include <rte_memzone.h>
44 #include <rte_malloc.h>
46 #include <rte_string_fns.h>
47 #include <rte_ethdev.h>
49 #include "enic_compat.h"
51 #include "wq_enet_desc.h"
52 #include "rq_enet_desc.h"
53 #include "cq_enet_desc.h"
54 #include "vnic_enet.h"
59 #include "vnic_intr.h"
61 #include "enic_vnic_wq.h"
63 static inline int enic_is_sriov_vf(struct enic *enic)
65 return enic->pdev->id.device_id == PCI_DEVICE_ID_CISCO_VIC_ENET_VF;
68 static int is_zero_addr(uint8_t *addr)
70 return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
73 static int is_mcast_addr(uint8_t *addr)
78 static int is_eth_addr_valid(uint8_t *addr)
80 return !is_mcast_addr(addr) && !is_zero_addr(addr);
84 enic_rxmbuf_queue_release(struct enic *enic, struct vnic_rq *rq)
88 if (!rq || !rq->mbuf_ring) {
89 dev_debug(enic, "Pointer to rq or mbuf_ring is NULL");
93 for (i = 0; i < enic->config.rq_desc_count; i++) {
94 if (rq->mbuf_ring[i]) {
95 rte_pktmbuf_free_seg(rq->mbuf_ring[i]);
96 rq->mbuf_ring[i] = NULL;
102 void enic_set_hdr_split_size(struct enic *enic, u16 split_hdr_size)
104 vnic_set_hdr_split_size(enic->vdev, split_hdr_size);
107 static void enic_free_wq_buf(__rte_unused struct vnic_wq *wq, struct vnic_wq_buf *buf)
109 struct rte_mbuf *mbuf = (struct rte_mbuf *)buf->os_buf;
111 rte_mempool_put(mbuf->pool, mbuf);
115 static void enic_wq_free_buf(struct vnic_wq *wq,
116 __rte_unused struct cq_desc *cq_desc,
117 struct vnic_wq_buf *buf,
118 __rte_unused void *opaque)
120 enic_free_wq_buf(wq, buf);
123 static int enic_wq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
124 __rte_unused u8 type, u16 q_number, u16 completed_index, void *opaque)
126 struct enic *enic = vnic_dev_priv(vdev);
128 vnic_wq_service(&enic->wq[q_number], cq_desc,
129 completed_index, enic_wq_free_buf,
135 static void enic_log_q_error(struct enic *enic)
140 for (i = 0; i < enic->wq_count; i++) {
141 error_status = vnic_wq_error_status(&enic->wq[i]);
143 dev_err(enic, "WQ[%d] error_status %d\n", i,
147 for (i = 0; i < enic->rq_count; i++) {
148 error_status = vnic_rq_error_status(&enic->rq[i]);
150 dev_err(enic, "RQ[%d] error_status %d\n", i,
155 unsigned int enic_cleanup_wq(struct enic *enic, struct vnic_wq *wq)
157 unsigned int cq = enic_cq_wq(enic, wq->index);
159 /* Return the work done */
160 return vnic_cq_service(&enic->cq[cq],
161 -1 /*wq_work_to_do*/, enic_wq_service, NULL);
164 void enic_post_wq_index(struct vnic_wq *wq)
166 enic_vnic_post_wq_index(wq);
169 void enic_send_pkt(struct enic *enic, struct vnic_wq *wq,
170 struct rte_mbuf *tx_pkt, unsigned short len,
171 uint8_t sop, uint8_t eop, uint8_t cq_entry,
172 uint16_t ol_flags, uint16_t vlan_tag)
174 struct wq_enet_desc *desc = vnic_wq_next_desc(wq);
176 uint8_t vlan_tag_insert = 0;
177 uint64_t bus_addr = (dma_addr_t)
178 (tx_pkt->buf_physaddr + tx_pkt->data_off);
181 if (ol_flags & PKT_TX_VLAN_PKT)
184 if (enic->hw_ip_checksum) {
185 if (ol_flags & PKT_TX_IP_CKSUM)
186 mss |= ENIC_CALC_IP_CKSUM;
188 if (ol_flags & PKT_TX_TCP_UDP_CKSUM)
189 mss |= ENIC_CALC_TCP_UDP_CKSUM;
193 wq_enet_desc_enc(desc,
197 0 /* header_length */,
198 0 /* offload_mode WQ_ENET_OFFLOAD_MODE_CSUM */,
206 enic_vnic_post_wq(wq, (void *)tx_pkt, bus_addr, len,
210 0 /*compressed send*/,
214 static void enic_clear_soft_stats(struct enic *enic)
216 struct enic_soft_stats *soft_stats = &enic->soft_stats;
217 rte_atomic64_clear(&soft_stats->rx_nombuf);
220 static void enic_init_soft_stats(struct enic *enic)
222 struct enic_soft_stats *soft_stats = &enic->soft_stats;
223 rte_atomic64_init(&soft_stats->rx_nombuf);
224 enic_clear_soft_stats(enic);
227 void enic_dev_stats_clear(struct enic *enic)
229 if (vnic_dev_stats_clear(enic->vdev))
230 dev_err(enic, "Error in clearing stats\n");
231 enic_clear_soft_stats(enic);
234 void enic_dev_stats_get(struct enic *enic, struct rte_eth_stats *r_stats)
236 struct vnic_stats *stats;
237 struct enic_soft_stats *soft_stats;
239 if (vnic_dev_stats_dump(enic->vdev, &stats)) {
240 dev_err(enic, "Error in getting stats\n");
244 r_stats->ipackets = stats->rx.rx_frames_ok;
245 r_stats->opackets = stats->tx.tx_frames_ok;
247 r_stats->ibytes = stats->rx.rx_bytes_ok;
248 r_stats->obytes = stats->tx.tx_bytes_ok;
250 r_stats->ierrors = stats->rx.rx_errors + stats->rx.rx_drop;
251 r_stats->oerrors = stats->tx.tx_errors;
253 r_stats->imissed = stats->rx.rx_no_bufs;
255 soft_stats = &enic->soft_stats;
256 r_stats->rx_nombuf = rte_atomic64_read(&soft_stats->rx_nombuf);
259 void enic_del_mac_address(struct enic *enic)
261 if (vnic_dev_del_addr(enic->vdev, enic->mac_addr))
262 dev_err(enic, "del mac addr failed\n");
265 void enic_set_mac_address(struct enic *enic, uint8_t *mac_addr)
269 if (!is_eth_addr_valid(mac_addr)) {
270 dev_err(enic, "invalid mac address\n");
274 err = vnic_dev_del_addr(enic->vdev, mac_addr);
276 dev_err(enic, "del mac addr failed\n");
280 ether_addr_copy((struct ether_addr *)mac_addr,
281 (struct ether_addr *)enic->mac_addr);
283 err = vnic_dev_add_addr(enic->vdev, mac_addr);
285 dev_err(enic, "add mac addr failed\n");
291 enic_free_rq_buf(struct rte_mbuf **mbuf)
296 rte_pktmbuf_free(*mbuf);
300 void enic_init_vnic_resources(struct enic *enic)
302 unsigned int error_interrupt_enable = 1;
303 unsigned int error_interrupt_offset = 0;
304 unsigned int index = 0;
306 for (index = 0; index < enic->rq_count; index++) {
307 vnic_rq_init(&enic->rq[index],
308 enic_cq_rq(enic, index),
309 error_interrupt_enable,
310 error_interrupt_offset);
313 for (index = 0; index < enic->wq_count; index++) {
314 vnic_wq_init(&enic->wq[index],
315 enic_cq_wq(enic, index),
316 error_interrupt_enable,
317 error_interrupt_offset);
320 vnic_dev_stats_clear(enic->vdev);
322 for (index = 0; index < enic->cq_count; index++) {
323 vnic_cq_init(&enic->cq[index],
324 0 /* flow_control_enable */,
325 1 /* color_enable */,
328 1 /* cq_tail_color */,
329 0 /* interrupt_enable */,
330 1 /* cq_entry_enable */,
331 0 /* cq_message_enable */,
332 0 /* interrupt offset */,
333 0 /* cq_message_addr */);
336 vnic_intr_init(&enic->intr,
337 enic->config.intr_timer_usec,
338 enic->config.intr_timer_type,
339 /*mask_on_assertion*/1);
344 enic_alloc_rx_queue_mbufs(struct enic *enic, struct vnic_rq *rq)
347 struct rq_enet_desc *rqd = rq->ring.descs;
351 dev_debug(enic, "queue %u, allocating %u rx queue mbufs\n", rq->index,
352 rq->ring.desc_count);
354 for (i = 0; i < rq->ring.desc_count; i++, rqd++) {
355 mb = rte_mbuf_raw_alloc(rq->mp);
357 dev_err(enic, "RX mbuf alloc failed queue_id=%u\n",
358 (unsigned)rq->index);
362 dma_addr = (dma_addr_t)(mb->buf_physaddr
363 + RTE_PKTMBUF_HEADROOM);
365 rq_enet_desc_enc(rqd, dma_addr, RQ_ENET_TYPE_ONLY_SOP,
366 mb->buf_len - RTE_PKTMBUF_HEADROOM);
367 rq->mbuf_ring[i] = mb;
370 /* make sure all prior writes are complete before doing the PIO write */
373 /* Post all but the last 2 cache lines' worth of descriptors */
374 rq->posted_index = rq->ring.desc_count - (2 * RTE_CACHE_LINE_SIZE
375 / sizeof(struct rq_enet_desc));
378 dev_debug(enic, "port=%u, qidx=%u, Write %u posted idx, %u sw held\n",
379 enic->port_id, rq->index, rq->posted_index, rq->rx_nb_hold);
380 iowrite32(rq->posted_index, &rq->ctrl->posted_index);
388 enic_alloc_consistent(__rte_unused void *priv, size_t size,
389 dma_addr_t *dma_handle, u8 *name)
392 const struct rte_memzone *rz;
395 rz = rte_memzone_reserve_aligned((const char *)name,
396 size, SOCKET_ID_ANY, 0, ENIC_ALIGN);
398 pr_err("%s : Failed to allocate memory requested for %s\n",
404 *dma_handle = (dma_addr_t)rz->phys_addr;
410 enic_free_consistent(__rte_unused struct rte_pci_device *hwdev,
411 __rte_unused size_t size,
412 __rte_unused void *vaddr,
413 __rte_unused dma_addr_t dma_handle)
415 /* Nothing to be done */
419 enic_intr_handler(__rte_unused struct rte_intr_handle *handle,
422 struct enic *enic = pmd_priv((struct rte_eth_dev *)arg);
424 vnic_intr_return_all_credits(&enic->intr);
426 enic_log_q_error(enic);
429 int enic_enable(struct enic *enic)
433 struct rte_eth_dev *eth_dev = enic->rte_dev;
435 eth_dev->data->dev_link.link_speed = vnic_dev_port_speed(enic->vdev);
436 eth_dev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX;
437 vnic_dev_notify_set(enic->vdev, -1); /* No Intr for notify */
439 if (enic_clsf_init(enic))
440 dev_warning(enic, "Init of hash table for clsf failed."\
441 "Flow director feature will not work\n");
443 for (index = 0; index < enic->rq_count; index++) {
444 err = enic_alloc_rx_queue_mbufs(enic, &enic->rq[index]);
446 dev_err(enic, "Failed to alloc RX queue mbufs\n");
451 for (index = 0; index < enic->wq_count; index++)
452 vnic_wq_enable(&enic->wq[index]);
453 for (index = 0; index < enic->rq_count; index++)
454 vnic_rq_enable(&enic->rq[index]);
456 vnic_dev_enable_wait(enic->vdev);
458 /* Register and enable error interrupt */
459 rte_intr_callback_register(&(enic->pdev->intr_handle),
460 enic_intr_handler, (void *)enic->rte_dev);
462 rte_intr_enable(&(enic->pdev->intr_handle));
463 vnic_intr_unmask(&enic->intr);
468 int enic_alloc_intr_resources(struct enic *enic)
472 dev_info(enic, "vNIC resources used: "\
473 "wq %d rq %d cq %d intr %d\n",
474 enic->wq_count, enic->rq_count,
475 enic->cq_count, enic->intr_count);
477 err = vnic_intr_alloc(enic->vdev, &enic->intr, 0);
479 enic_free_vnic_resources(enic);
484 void enic_free_rq(void *rxq)
486 struct vnic_rq *rq = (struct vnic_rq *)rxq;
487 struct enic *enic = vnic_dev_priv(rq->vdev);
489 enic_rxmbuf_queue_release(enic, rq);
490 rte_free(rq->mbuf_ring);
491 rq->mbuf_ring = NULL;
493 vnic_cq_free(&enic->cq[rq->index]);
496 void enic_start_wq(struct enic *enic, uint16_t queue_idx)
498 vnic_wq_enable(&enic->wq[queue_idx]);
501 int enic_stop_wq(struct enic *enic, uint16_t queue_idx)
503 return vnic_wq_disable(&enic->wq[queue_idx]);
506 void enic_start_rq(struct enic *enic, uint16_t queue_idx)
508 vnic_rq_enable(&enic->rq[queue_idx]);
511 int enic_stop_rq(struct enic *enic, uint16_t queue_idx)
513 return vnic_rq_disable(&enic->rq[queue_idx]);
516 int enic_alloc_rq(struct enic *enic, uint16_t queue_idx,
517 unsigned int socket_id, struct rte_mempool *mp,
521 struct vnic_rq *rq = &enic->rq[queue_idx];
523 rq->socket_id = socket_id;
527 if (nb_desc > enic->config.rq_desc_count) {
529 "RQ %d - number of rx desc in cmd line (%d)"\
530 "is greater than that in the UCSM/CIMC adapter"\
531 "policy. Applying the value in the adapter "\
533 queue_idx, nb_desc, enic->config.rq_desc_count);
534 nb_desc = enic->config.rq_desc_count;
536 dev_info(enic, "RX Queues - effective number of descs:%d\n",
540 /* Allocate queue resources */
541 rc = vnic_rq_alloc(enic->vdev, rq, queue_idx,
542 nb_desc, sizeof(struct rq_enet_desc));
544 dev_err(enic, "error in allocation of rq\n");
548 rc = vnic_cq_alloc(enic->vdev, &enic->cq[queue_idx], queue_idx,
550 sizeof(struct cq_enet_rq_desc));
552 dev_err(enic, "error in allocation of cq for rq\n");
553 goto err_free_rq_exit;
556 /* Allocate the mbuf ring */
557 rq->mbuf_ring = (struct rte_mbuf **)rte_zmalloc_socket("rq->mbuf_ring",
558 sizeof(struct rte_mbuf *) * nb_desc,
559 RTE_CACHE_LINE_SIZE, rq->socket_id);
561 if (rq->mbuf_ring != NULL)
564 /* cleanup on error */
565 vnic_cq_free(&enic->cq[queue_idx]);
572 void enic_free_wq(void *txq)
574 struct vnic_wq *wq = (struct vnic_wq *)txq;
575 struct enic *enic = vnic_dev_priv(wq->vdev);
578 vnic_cq_free(&enic->cq[enic->rq_count + wq->index]);
581 int enic_alloc_wq(struct enic *enic, uint16_t queue_idx,
582 unsigned int socket_id, uint16_t nb_desc)
585 struct vnic_wq *wq = &enic->wq[queue_idx];
586 unsigned int cq_index = enic_cq_wq(enic, queue_idx);
588 wq->socket_id = socket_id;
590 if (nb_desc > enic->config.wq_desc_count) {
592 "WQ %d - number of tx desc in cmd line (%d)"\
593 "is greater than that in the UCSM/CIMC adapter"\
594 "policy. Applying the value in the adapter "\
596 queue_idx, nb_desc, enic->config.wq_desc_count);
597 } else if (nb_desc != enic->config.wq_desc_count) {
598 enic->config.wq_desc_count = nb_desc;
600 "TX Queues - effective number of descs:%d\n",
605 /* Allocate queue resources */
606 err = vnic_wq_alloc(enic->vdev, &enic->wq[queue_idx], queue_idx,
607 enic->config.wq_desc_count,
608 sizeof(struct wq_enet_desc));
610 dev_err(enic, "error in allocation of wq\n");
614 err = vnic_cq_alloc(enic->vdev, &enic->cq[cq_index], cq_index,
615 socket_id, enic->config.wq_desc_count,
616 sizeof(struct cq_enet_wq_desc));
619 dev_err(enic, "error in allocation of cq for wq\n");
625 int enic_disable(struct enic *enic)
630 vnic_intr_mask(&enic->intr);
631 (void)vnic_intr_masked(&enic->intr); /* flush write */
633 vnic_dev_disable(enic->vdev);
635 enic_clsf_destroy(enic);
637 if (!enic_is_sriov_vf(enic))
638 vnic_dev_del_addr(enic->vdev, enic->mac_addr);
640 for (i = 0; i < enic->wq_count; i++) {
641 err = vnic_wq_disable(&enic->wq[i]);
645 for (i = 0; i < enic->rq_count; i++) {
646 err = vnic_rq_disable(&enic->rq[i]);
651 vnic_dev_set_reset_flag(enic->vdev, 1);
652 vnic_dev_notify_unset(enic->vdev);
654 for (i = 0; i < enic->wq_count; i++)
655 vnic_wq_clean(&enic->wq[i], enic_free_wq_buf);
657 for (i = 0; i < enic->rq_count; i++)
658 vnic_rq_clean(&enic->rq[i], enic_free_rq_buf);
659 for (i = 0; i < enic->cq_count; i++)
660 vnic_cq_clean(&enic->cq[i]);
661 vnic_intr_clean(&enic->intr);
666 static int enic_dev_wait(struct vnic_dev *vdev,
667 int (*start)(struct vnic_dev *, int),
668 int (*finished)(struct vnic_dev *, int *),
675 err = start(vdev, arg);
679 /* Wait for func to complete...2 seconds max */
680 for (i = 0; i < 2000; i++) {
681 err = finished(vdev, &done);
691 static int enic_dev_open(struct enic *enic)
695 err = enic_dev_wait(enic->vdev, vnic_dev_open,
696 vnic_dev_open_done, 0);
698 dev_err(enic_get_dev(enic),
699 "vNIC device open failed, err %d\n", err);
704 static int enic_set_rsskey(struct enic *enic)
706 dma_addr_t rss_key_buf_pa;
707 union vnic_rss_key *rss_key_buf_va = NULL;
708 static union vnic_rss_key rss_key = {
710 [0] = {.b = {85, 67, 83, 97, 119, 101, 115, 111, 109, 101}},
711 [1] = {.b = {80, 65, 76, 79, 117, 110, 105, 113, 117, 101}},
712 [2] = {.b = {76, 73, 78, 85, 88, 114, 111, 99, 107, 115}},
713 [3] = {.b = {69, 78, 73, 67, 105, 115, 99, 111, 111, 108}},
719 snprintf((char *)name, NAME_MAX, "rss_key-%s", enic->bdf_name);
720 rss_key_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_key),
721 &rss_key_buf_pa, name);
725 rte_memcpy(rss_key_buf_va, &rss_key, sizeof(union vnic_rss_key));
727 err = enic_set_rss_key(enic,
729 sizeof(union vnic_rss_key));
731 enic_free_consistent(enic->pdev, sizeof(union vnic_rss_key),
732 rss_key_buf_va, rss_key_buf_pa);
737 static int enic_set_rsscpu(struct enic *enic, u8 rss_hash_bits)
739 dma_addr_t rss_cpu_buf_pa;
740 union vnic_rss_cpu *rss_cpu_buf_va = NULL;
745 snprintf((char *)name, NAME_MAX, "rss_cpu-%s", enic->bdf_name);
746 rss_cpu_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_cpu),
747 &rss_cpu_buf_pa, name);
751 for (i = 0; i < (1 << rss_hash_bits); i++)
752 (*rss_cpu_buf_va).cpu[i/4].b[i%4] = i % enic->rq_count;
754 err = enic_set_rss_cpu(enic,
756 sizeof(union vnic_rss_cpu));
758 enic_free_consistent(enic->pdev, sizeof(union vnic_rss_cpu),
759 rss_cpu_buf_va, rss_cpu_buf_pa);
764 static int enic_set_niccfg(struct enic *enic, u8 rss_default_cpu,
765 u8 rss_hash_type, u8 rss_hash_bits, u8 rss_base_cpu, u8 rss_enable)
767 const u8 tso_ipid_split_en = 0;
770 /* Enable VLAN tag stripping */
772 err = enic_set_nic_cfg(enic,
773 rss_default_cpu, rss_hash_type,
774 rss_hash_bits, rss_base_cpu,
775 rss_enable, tso_ipid_split_en,
776 enic->ig_vlan_strip_en);
781 int enic_set_rss_nic_cfg(struct enic *enic)
783 const u8 rss_default_cpu = 0;
784 const u8 rss_hash_type = NIC_CFG_RSS_HASH_TYPE_IPV4 |
785 NIC_CFG_RSS_HASH_TYPE_TCP_IPV4 |
786 NIC_CFG_RSS_HASH_TYPE_IPV6 |
787 NIC_CFG_RSS_HASH_TYPE_TCP_IPV6;
788 const u8 rss_hash_bits = 7;
789 const u8 rss_base_cpu = 0;
790 u8 rss_enable = ENIC_SETTING(enic, RSS) && (enic->rq_count > 1);
793 if (!enic_set_rsskey(enic)) {
794 if (enic_set_rsscpu(enic, rss_hash_bits)) {
796 dev_warning(enic, "RSS disabled, "\
797 "Failed to set RSS cpu indirection table.");
802 "RSS disabled, Failed to set RSS key.\n");
806 return enic_set_niccfg(enic, rss_default_cpu, rss_hash_type,
807 rss_hash_bits, rss_base_cpu, rss_enable);
810 int enic_setup_finish(struct enic *enic)
814 enic_init_soft_stats(enic);
816 ret = enic_set_rss_nic_cfg(enic);
818 dev_err(enic, "Failed to config nic, aborting.\n");
822 vnic_dev_add_addr(enic->vdev, enic->mac_addr);
825 vnic_dev_packet_filter(enic->vdev,
838 void enic_add_packet_filter(struct enic *enic)
840 /* Args -> directed, multicast, broadcast, promisc, allmulti */
841 vnic_dev_packet_filter(enic->vdev, 1, 1, 1,
842 enic->promisc, enic->allmulti);
845 int enic_get_link_status(struct enic *enic)
847 return vnic_dev_link_status(enic->vdev);
850 static void enic_dev_deinit(struct enic *enic)
852 struct rte_eth_dev *eth_dev = enic->rte_dev;
854 rte_free(eth_dev->data->mac_addrs);
858 int enic_set_vnic_res(struct enic *enic)
860 struct rte_eth_dev *eth_dev = enic->rte_dev;
862 if ((enic->rq_count < eth_dev->data->nb_rx_queues) ||
863 (enic->wq_count < eth_dev->data->nb_tx_queues)) {
864 dev_err(dev, "Not enough resources configured, aborting\n");
868 enic->rq_count = eth_dev->data->nb_rx_queues;
869 enic->wq_count = eth_dev->data->nb_tx_queues;
870 if (enic->cq_count < (enic->rq_count + enic->wq_count)) {
871 dev_err(dev, "Not enough resources configured, aborting\n");
875 enic->cq_count = enic->rq_count + enic->wq_count;
879 static int enic_dev_init(struct enic *enic)
882 struct rte_eth_dev *eth_dev = enic->rte_dev;
884 vnic_dev_intr_coal_timer_info_default(enic->vdev);
886 /* Get vNIC configuration
888 err = enic_get_vnic_config(enic);
890 dev_err(dev, "Get vNIC configuration failed, aborting\n");
894 eth_dev->data->mac_addrs = rte_zmalloc("enic_mac_addr", ETH_ALEN, 0);
895 if (!eth_dev->data->mac_addrs) {
896 dev_err(enic, "mac addr storage alloc failed, aborting.\n");
899 ether_addr_copy((struct ether_addr *) enic->mac_addr,
900 ð_dev->data->mac_addrs[0]);
903 /* Get available resource counts
905 enic_get_res_counts(enic);
907 vnic_dev_set_reset_flag(enic->vdev, 0);
913 int enic_probe(struct enic *enic)
915 struct rte_pci_device *pdev = enic->pdev;
918 dev_debug(enic, " Initializing ENIC PMD version %s\n", DRV_VERSION);
920 enic->bar0.vaddr = (void *)pdev->mem_resource[0].addr;
921 enic->bar0.len = pdev->mem_resource[0].len;
923 /* Register vNIC device */
924 enic->vdev = vnic_dev_register(NULL, enic, enic->pdev, &enic->bar0, 1);
926 dev_err(enic, "vNIC registration failed, aborting\n");
930 vnic_register_cbacks(enic->vdev,
931 enic_alloc_consistent,
932 enic_free_consistent);
934 /* Issue device open to get device in known state */
935 err = enic_dev_open(enic);
937 dev_err(enic, "vNIC dev open failed, aborting\n");
938 goto err_out_unregister;
941 /* Set ingress vlan rewrite mode before vnic initialization */
942 err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
943 IG_VLAN_REWRITE_MODE_PASS_THRU);
946 "Failed to set ingress vlan rewrite mode, aborting.\n");
947 goto err_out_dev_close;
950 /* Issue device init to initialize the vnic-to-switch link.
951 * We'll start with carrier off and wait for link UP
952 * notification later to turn on carrier. We don't need
953 * to wait here for the vnic-to-switch link initialization
954 * to complete; link UP notification is the indication that
955 * the process is complete.
958 err = vnic_dev_init(enic->vdev, 0);
960 dev_err(enic, "vNIC dev init failed, aborting\n");
961 goto err_out_dev_close;
964 err = enic_dev_init(enic);
966 dev_err(enic, "Device initialization failed, aborting\n");
967 goto err_out_dev_close;
973 vnic_dev_close(enic->vdev);
975 vnic_dev_unregister(enic->vdev);
980 void enic_remove(struct enic *enic)
982 enic_dev_deinit(enic);
983 vnic_dev_close(enic->vdev);
984 vnic_dev_unregister(enic->vdev);