enic/base: common code
authorSujith Sankar <ssujith@cisco.com>
Tue, 25 Nov 2014 17:26:42 +0000 (22:56 +0530)
committerThomas Monjalon <thomas.monjalon@6wind.com>
Wed, 26 Nov 2014 22:07:11 +0000 (23:07 +0100)
VNIC common code is partially shared with ENIC kernel mode driver.

Signed-off-by: Sujith Sankar <ssujith@cisco.com>
Acked-by: David Marchand <david.marchand@6wind.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
21 files changed:
lib/librte_pmd_enic/vnic/cq_desc.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/cq_enet_desc.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/rq_enet_desc.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_cq.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_cq.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_dev.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_dev.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_devcmd.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_enet.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_intr.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_intr.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_nic.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_resource.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_rq.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_rq.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_rss.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_rss.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_stats.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_wq.c [new file with mode: 0644]
lib/librte_pmd_enic/vnic/vnic_wq.h [new file with mode: 0644]
lib/librte_pmd_enic/vnic/wq_enet_desc.h [new file with mode: 0644]

diff --git a/lib/librte_pmd_enic/vnic/cq_desc.h b/lib/librte_pmd_enic/vnic/cq_desc.h
new file mode 100644 (file)
index 0000000..c418967
--- /dev/null
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: cq_desc.h 129574 2013-04-26 22:11:14Z rfaucett $"
+
+#ifndef _CQ_DESC_H_
+#define _CQ_DESC_H_
+
+/*
+ * Completion queue descriptor types
+ */
+enum cq_desc_types {
+       CQ_DESC_TYPE_WQ_ENET = 0,
+       CQ_DESC_TYPE_DESC_COPY = 1,
+       CQ_DESC_TYPE_WQ_EXCH = 2,
+       CQ_DESC_TYPE_RQ_ENET = 3,
+       CQ_DESC_TYPE_RQ_FCP = 4,
+       CQ_DESC_TYPE_IOMMU_MISS = 5,
+       CQ_DESC_TYPE_SGL = 6,
+       CQ_DESC_TYPE_CLASSIFIER = 7,
+       CQ_DESC_TYPE_TEST = 127,
+};
+
+/* Completion queue descriptor: 16B
+ *
+ * All completion queues have this basic layout.  The
+ * type_specfic area is unique for each completion
+ * queue type.
+ */
+struct cq_desc {
+       __le16 completed_index;
+       __le16 q_number;
+       u8 type_specfic[11];
+       u8 type_color;
+};
+
+#define CQ_DESC_TYPE_BITS        4
+#define CQ_DESC_TYPE_MASK        ((1 << CQ_DESC_TYPE_BITS) - 1)
+#define CQ_DESC_COLOR_MASK       1
+#define CQ_DESC_COLOR_SHIFT      7
+#define CQ_DESC_Q_NUM_BITS       10
+#define CQ_DESC_Q_NUM_MASK       ((1 << CQ_DESC_Q_NUM_BITS) - 1)
+#define CQ_DESC_COMP_NDX_BITS    12
+#define CQ_DESC_COMP_NDX_MASK    ((1 << CQ_DESC_COMP_NDX_BITS) - 1)
+
+static inline void cq_color_enc(struct cq_desc *desc, const u8 color)
+{
+       if (color)
+               desc->type_color |=  (1 << CQ_DESC_COLOR_SHIFT);
+       else
+               desc->type_color &= ~(1 << CQ_DESC_COLOR_SHIFT);
+}
+
+static inline void cq_desc_enc(struct cq_desc *desc,
+       const u8 type, const u8 color, const u16 q_number,
+       const u16 completed_index)
+{
+       desc->type_color = (type & CQ_DESC_TYPE_MASK) |
+               ((color & CQ_DESC_COLOR_MASK) << CQ_DESC_COLOR_SHIFT);
+       desc->q_number = cpu_to_le16(q_number & CQ_DESC_Q_NUM_MASK);
+       desc->completed_index = cpu_to_le16(completed_index &
+               CQ_DESC_COMP_NDX_MASK);
+}
+
+static inline void cq_desc_dec(const struct cq_desc *desc_arg,
+       u8 *type, u8 *color, u16 *q_number, u16 *completed_index)
+{
+       const struct cq_desc *desc = desc_arg;
+       const u8 type_color = desc->type_color;
+
+       *color = (type_color >> CQ_DESC_COLOR_SHIFT) & CQ_DESC_COLOR_MASK;
+
+       /*
+        * Make sure color bit is read from desc *before* other fields
+        * are read from desc.  Hardware guarantees color bit is last
+        * bit (byte) written.  Adding the rmb() prevents the compiler
+        * and/or CPU from reordering the reads which would potentially
+        * result in reading stale values.
+        */
+
+       rmb();
+
+       *type = type_color & CQ_DESC_TYPE_MASK;
+       *q_number = le16_to_cpu(desc->q_number) & CQ_DESC_Q_NUM_MASK;
+       *completed_index = le16_to_cpu(desc->completed_index) &
+               CQ_DESC_COMP_NDX_MASK;
+}
+
+static inline void cq_color_dec(const struct cq_desc *desc_arg, u8 *color)
+{
+       volatile const struct cq_desc *desc = desc_arg;
+
+       *color = (desc->type_color >> CQ_DESC_COLOR_SHIFT) & CQ_DESC_COLOR_MASK;
+}
+
+#endif /* _CQ_DESC_H_ */
diff --git a/lib/librte_pmd_enic/vnic/cq_enet_desc.h b/lib/librte_pmd_enic/vnic/cq_enet_desc.h
new file mode 100644 (file)
index 0000000..669a2b5
--- /dev/null
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: cq_enet_desc.h 160468 2014-02-18 09:50:15Z gvaradar $"
+
+#ifndef _CQ_ENET_DESC_H_
+#define _CQ_ENET_DESC_H_
+
+#include "cq_desc.h"
+
+/* Ethernet completion queue descriptor: 16B */
+struct cq_enet_wq_desc {
+       __le16 completed_index;
+       __le16 q_number;
+       u8 reserved[11];
+       u8 type_color;
+};
+
+static inline void cq_enet_wq_desc_enc(struct cq_enet_wq_desc *desc,
+       u8 type, u8 color, u16 q_number, u16 completed_index)
+{
+       cq_desc_enc((struct cq_desc *)desc, type,
+               color, q_number, completed_index);
+}
+
+static inline void cq_enet_wq_desc_dec(struct cq_enet_wq_desc *desc,
+       u8 *type, u8 *color, u16 *q_number, u16 *completed_index)
+{
+       cq_desc_dec((struct cq_desc *)desc, type,
+               color, q_number, completed_index);
+}
+
+/* Completion queue descriptor: Ethernet receive queue, 16B */
+struct cq_enet_rq_desc {
+       __le16 completed_index_flags;
+       __le16 q_number_rss_type_flags;
+       __le32 rss_hash;
+       __le16 bytes_written_flags;
+       __le16 vlan;
+       __le16 checksum_fcoe;
+       u8 flags;
+       u8 type_color;
+};
+
+#define CQ_ENET_RQ_DESC_FLAGS_INGRESS_PORT          (0x1 << 12)
+#define CQ_ENET_RQ_DESC_FLAGS_FCOE                  (0x1 << 13)
+#define CQ_ENET_RQ_DESC_FLAGS_EOP                   (0x1 << 14)
+#define CQ_ENET_RQ_DESC_FLAGS_SOP                   (0x1 << 15)
+
+#define CQ_ENET_RQ_DESC_RSS_TYPE_BITS               4
+#define CQ_ENET_RQ_DESC_RSS_TYPE_MASK \
+       ((1 << CQ_ENET_RQ_DESC_RSS_TYPE_BITS) - 1)
+#define CQ_ENET_RQ_DESC_RSS_TYPE_NONE               0
+#define CQ_ENET_RQ_DESC_RSS_TYPE_IPv4               1
+#define CQ_ENET_RQ_DESC_RSS_TYPE_TCP_IPv4           2
+#define CQ_ENET_RQ_DESC_RSS_TYPE_IPv6               3
+#define CQ_ENET_RQ_DESC_RSS_TYPE_TCP_IPv6           4
+#define CQ_ENET_RQ_DESC_RSS_TYPE_IPv6_EX            5
+#define CQ_ENET_RQ_DESC_RSS_TYPE_TCP_IPv6_EX        6
+
+#define CQ_ENET_RQ_DESC_FLAGS_CSUM_NOT_CALC         (0x1 << 14)
+
+#define CQ_ENET_RQ_DESC_BYTES_WRITTEN_BITS          14
+#define CQ_ENET_RQ_DESC_BYTES_WRITTEN_MASK \
+       ((1 << CQ_ENET_RQ_DESC_BYTES_WRITTEN_BITS) - 1)
+#define CQ_ENET_RQ_DESC_FLAGS_TRUNCATED             (0x1 << 14)
+#define CQ_ENET_RQ_DESC_FLAGS_VLAN_STRIPPED         (0x1 << 15)
+
+#define CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_BITS          12
+#define CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_MASK \
+       ((1 << CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_BITS) - 1)
+#define CQ_ENET_RQ_DESC_VLAN_TCI_CFI_MASK           (0x1 << 12)
+#define CQ_ENET_RQ_DESC_VLAN_TCI_USER_PRIO_BITS     3
+#define CQ_ENET_RQ_DESC_VLAN_TCI_USER_PRIO_MASK \
+       ((1 << CQ_ENET_RQ_DESC_VLAN_TCI_USER_PRIO_BITS) - 1)
+#define CQ_ENET_RQ_DESC_VLAN_TCI_USER_PRIO_SHIFT    13
+
+#define CQ_ENET_RQ_DESC_FCOE_SOF_BITS               8
+#define CQ_ENET_RQ_DESC_FCOE_SOF_MASK \
+       ((1 << CQ_ENET_RQ_DESC_FCOE_SOF_BITS) - 1)
+#define CQ_ENET_RQ_DESC_FCOE_EOF_BITS               8
+#define CQ_ENET_RQ_DESC_FCOE_EOF_MASK \
+       ((1 << CQ_ENET_RQ_DESC_FCOE_EOF_BITS) - 1)
+#define CQ_ENET_RQ_DESC_FCOE_EOF_SHIFT              8
+
+#define CQ_ENET_RQ_DESC_FLAGS_TCP_UDP_CSUM_OK       (0x1 << 0)
+#define CQ_ENET_RQ_DESC_FCOE_FC_CRC_OK              (0x1 << 0)
+#define CQ_ENET_RQ_DESC_FLAGS_UDP                   (0x1 << 1)
+#define CQ_ENET_RQ_DESC_FCOE_ENC_ERROR              (0x1 << 1)
+#define CQ_ENET_RQ_DESC_FLAGS_TCP                   (0x1 << 2)
+#define CQ_ENET_RQ_DESC_FLAGS_IPV4_CSUM_OK          (0x1 << 3)
+#define CQ_ENET_RQ_DESC_FLAGS_IPV6                  (0x1 << 4)
+#define CQ_ENET_RQ_DESC_FLAGS_IPV4                  (0x1 << 5)
+#define CQ_ENET_RQ_DESC_FLAGS_IPV4_FRAGMENT         (0x1 << 6)
+#define CQ_ENET_RQ_DESC_FLAGS_FCS_OK                (0x1 << 7)
+
+static inline void cq_enet_rq_desc_enc(struct cq_enet_rq_desc *desc,
+       u8 type, u8 color, u16 q_number, u16 completed_index,
+       u8 ingress_port, u8 fcoe, u8 eop, u8 sop, u8 rss_type, u8 csum_not_calc,
+       u32 rss_hash, u16 bytes_written, u8 packet_error, u8 vlan_stripped,
+       u16 vlan, u16 checksum, u8 fcoe_sof, u8 fcoe_fc_crc_ok,
+       u8 fcoe_enc_error, u8 fcoe_eof, u8 tcp_udp_csum_ok, u8 udp, u8 tcp,
+       u8 ipv4_csum_ok, u8 ipv6, u8 ipv4, u8 ipv4_fragment, u8 fcs_ok)
+{
+       cq_desc_enc((struct cq_desc *)desc, type,
+               color, q_number, completed_index);
+
+       desc->completed_index_flags |= cpu_to_le16(
+               (ingress_port ? CQ_ENET_RQ_DESC_FLAGS_INGRESS_PORT : 0) |
+               (fcoe ? CQ_ENET_RQ_DESC_FLAGS_FCOE : 0) |
+               (eop ? CQ_ENET_RQ_DESC_FLAGS_EOP : 0) |
+               (sop ? CQ_ENET_RQ_DESC_FLAGS_SOP : 0));
+
+       desc->q_number_rss_type_flags |= cpu_to_le16(
+               ((rss_type & CQ_ENET_RQ_DESC_RSS_TYPE_MASK) <<
+               CQ_DESC_Q_NUM_BITS) |
+               (csum_not_calc ? CQ_ENET_RQ_DESC_FLAGS_CSUM_NOT_CALC : 0));
+
+       desc->rss_hash = cpu_to_le32(rss_hash);
+
+       desc->bytes_written_flags = cpu_to_le16(
+               (bytes_written & CQ_ENET_RQ_DESC_BYTES_WRITTEN_MASK) |
+               (packet_error ? CQ_ENET_RQ_DESC_FLAGS_TRUNCATED : 0) |
+               (vlan_stripped ? CQ_ENET_RQ_DESC_FLAGS_VLAN_STRIPPED : 0));
+
+       desc->vlan = cpu_to_le16(vlan);
+
+       if (fcoe) {
+               desc->checksum_fcoe = cpu_to_le16(
+                       (fcoe_sof & CQ_ENET_RQ_DESC_FCOE_SOF_MASK) |
+                       ((fcoe_eof & CQ_ENET_RQ_DESC_FCOE_EOF_MASK) <<
+                               CQ_ENET_RQ_DESC_FCOE_EOF_SHIFT));
+       } else {
+               desc->checksum_fcoe = cpu_to_le16(checksum);
+       }
+
+       desc->flags =
+               (tcp_udp_csum_ok ? CQ_ENET_RQ_DESC_FLAGS_TCP_UDP_CSUM_OK : 0) |
+               (udp ? CQ_ENET_RQ_DESC_FLAGS_UDP : 0) |
+               (tcp ? CQ_ENET_RQ_DESC_FLAGS_TCP : 0) |
+               (ipv4_csum_ok ? CQ_ENET_RQ_DESC_FLAGS_IPV4_CSUM_OK : 0) |
+               (ipv6 ? CQ_ENET_RQ_DESC_FLAGS_IPV6 : 0) |
+               (ipv4 ? CQ_ENET_RQ_DESC_FLAGS_IPV4 : 0) |
+               (ipv4_fragment ? CQ_ENET_RQ_DESC_FLAGS_IPV4_FRAGMENT : 0) |
+               (fcs_ok ? CQ_ENET_RQ_DESC_FLAGS_FCS_OK : 0) |
+               (fcoe_fc_crc_ok ? CQ_ENET_RQ_DESC_FCOE_FC_CRC_OK : 0) |
+               (fcoe_enc_error ? CQ_ENET_RQ_DESC_FCOE_ENC_ERROR : 0);
+}
+
+static inline void cq_enet_rq_desc_dec(struct cq_enet_rq_desc *desc,
+       u8 *type, u8 *color, u16 *q_number, u16 *completed_index,
+       u8 *ingress_port, u8 *fcoe, u8 *eop, u8 *sop, u8 *rss_type,
+       u8 *csum_not_calc, u32 *rss_hash, u16 *bytes_written, u8 *packet_error,
+       u8 *vlan_stripped, u16 *vlan_tci, u16 *checksum, u8 *fcoe_sof,
+       u8 *fcoe_fc_crc_ok, u8 *fcoe_enc_error, u8 *fcoe_eof,
+       u8 *tcp_udp_csum_ok, u8 *udp, u8 *tcp, u8 *ipv4_csum_ok,
+       u8 *ipv6, u8 *ipv4, u8 *ipv4_fragment, u8 *fcs_ok)
+{
+       u16 completed_index_flags;
+       u16 q_number_rss_type_flags;
+       u16 bytes_written_flags;
+
+       cq_desc_dec((struct cq_desc *)desc, type,
+               color, q_number, completed_index);
+
+       completed_index_flags = le16_to_cpu(desc->completed_index_flags);
+       q_number_rss_type_flags =
+               le16_to_cpu(desc->q_number_rss_type_flags);
+       bytes_written_flags = le16_to_cpu(desc->bytes_written_flags);
+
+       *ingress_port = (completed_index_flags &
+               CQ_ENET_RQ_DESC_FLAGS_INGRESS_PORT) ? 1 : 0;
+       *fcoe = (completed_index_flags & CQ_ENET_RQ_DESC_FLAGS_FCOE) ?
+               1 : 0;
+       *eop = (completed_index_flags & CQ_ENET_RQ_DESC_FLAGS_EOP) ?
+               1 : 0;
+       *sop = (completed_index_flags & CQ_ENET_RQ_DESC_FLAGS_SOP) ?
+               1 : 0;
+
+       *rss_type = (u8)((q_number_rss_type_flags >> CQ_DESC_Q_NUM_BITS) &
+               CQ_ENET_RQ_DESC_RSS_TYPE_MASK);
+       *csum_not_calc = (q_number_rss_type_flags &
+               CQ_ENET_RQ_DESC_FLAGS_CSUM_NOT_CALC) ? 1 : 0;
+
+       *rss_hash = le32_to_cpu(desc->rss_hash);
+
+       *bytes_written = bytes_written_flags &
+               CQ_ENET_RQ_DESC_BYTES_WRITTEN_MASK;
+       *packet_error = (bytes_written_flags &
+               CQ_ENET_RQ_DESC_FLAGS_TRUNCATED) ? 1 : 0;
+       *vlan_stripped = (bytes_written_flags &
+               CQ_ENET_RQ_DESC_FLAGS_VLAN_STRIPPED) ? 1 : 0;
+
+       /*
+        * Tag Control Information(16) = user_priority(3) + cfi(1) + vlan(12)
+        */
+       *vlan_tci = le16_to_cpu(desc->vlan);
+
+       if (*fcoe) {
+               *fcoe_sof = (u8)(le16_to_cpu(desc->checksum_fcoe) &
+                       CQ_ENET_RQ_DESC_FCOE_SOF_MASK);
+               *fcoe_fc_crc_ok = (desc->flags &
+                       CQ_ENET_RQ_DESC_FCOE_FC_CRC_OK) ? 1 : 0;
+               *fcoe_enc_error = (desc->flags &
+                       CQ_ENET_RQ_DESC_FCOE_ENC_ERROR) ? 1 : 0;
+               *fcoe_eof = (u8)((le16_to_cpu(desc->checksum_fcoe) >>
+                       CQ_ENET_RQ_DESC_FCOE_EOF_SHIFT) &
+                       CQ_ENET_RQ_DESC_FCOE_EOF_MASK);
+               *checksum = 0;
+       } else {
+               *fcoe_sof = 0;
+               *fcoe_fc_crc_ok = 0;
+               *fcoe_enc_error = 0;
+               *fcoe_eof = 0;
+               *checksum = le16_to_cpu(desc->checksum_fcoe);
+       }
+
+       *tcp_udp_csum_ok =
+               (desc->flags & CQ_ENET_RQ_DESC_FLAGS_TCP_UDP_CSUM_OK) ? 1 : 0;
+       *udp = (desc->flags & CQ_ENET_RQ_DESC_FLAGS_UDP) ? 1 : 0;
+       *tcp = (desc->flags & CQ_ENET_RQ_DESC_FLAGS_TCP) ? 1 : 0;
+       *ipv4_csum_ok =
+               (desc->flags & CQ_ENET_RQ_DESC_FLAGS_IPV4_CSUM_OK) ? 1 : 0;
+       *ipv6 = (desc->flags & CQ_ENET_RQ_DESC_FLAGS_IPV6) ? 1 : 0;
+       *ipv4 = (desc->flags & CQ_ENET_RQ_DESC_FLAGS_IPV4) ? 1 : 0;
+       *ipv4_fragment =
+               (desc->flags & CQ_ENET_RQ_DESC_FLAGS_IPV4_FRAGMENT) ? 1 : 0;
+       *fcs_ok = (desc->flags & CQ_ENET_RQ_DESC_FLAGS_FCS_OK) ? 1 : 0;
+}
+
+#endif /* _CQ_ENET_DESC_H_ */
diff --git a/lib/librte_pmd_enic/vnic/rq_enet_desc.h b/lib/librte_pmd_enic/vnic/rq_enet_desc.h
new file mode 100644 (file)
index 0000000..f38ff2a
--- /dev/null
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: rq_enet_desc.h 59839 2010-09-27 20:36:31Z roprabhu $"
+
+#ifndef _RQ_ENET_DESC_H_
+#define _RQ_ENET_DESC_H_
+
+/* Ethernet receive queue descriptor: 16B */
+struct rq_enet_desc {
+       __le64 address;
+       __le16 length_type;
+       u8 reserved[6];
+};
+
+enum rq_enet_type_types {
+       RQ_ENET_TYPE_ONLY_SOP = 0,
+       RQ_ENET_TYPE_NOT_SOP = 1,
+       RQ_ENET_TYPE_RESV2 = 2,
+       RQ_ENET_TYPE_RESV3 = 3,
+};
+
+#define RQ_ENET_ADDR_BITS              64
+#define RQ_ENET_LEN_BITS               14
+#define RQ_ENET_LEN_MASK               ((1 << RQ_ENET_LEN_BITS) - 1)
+#define RQ_ENET_TYPE_BITS              2
+#define RQ_ENET_TYPE_MASK              ((1 << RQ_ENET_TYPE_BITS) - 1)
+
+static inline void rq_enet_desc_enc(struct rq_enet_desc *desc,
+       u64 address, u8 type, u16 length)
+{
+       desc->address = cpu_to_le64(address);
+       desc->length_type = cpu_to_le16((length & RQ_ENET_LEN_MASK) |
+               ((type & RQ_ENET_TYPE_MASK) << RQ_ENET_LEN_BITS));
+}
+
+static inline void rq_enet_desc_dec(struct rq_enet_desc *desc,
+       u64 *address, u8 *type, u16 *length)
+{
+       *address = le64_to_cpu(desc->address);
+       *length = le16_to_cpu(desc->length_type) & RQ_ENET_LEN_MASK;
+       *type = (u8)((le16_to_cpu(desc->length_type) >> RQ_ENET_LEN_BITS) &
+               RQ_ENET_TYPE_MASK);
+}
+
+#endif /* _RQ_ENET_DESC_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_cq.c b/lib/librte_pmd_enic/vnic/vnic_cq.c
new file mode 100644 (file)
index 0000000..cda97e4
--- /dev/null
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_cq.c 171146 2014-05-02 07:08:20Z ssujith $"
+
+#include "vnic_dev.h"
+#include "vnic_cq.h"
+
+int vnic_cq_mem_size(struct vnic_cq *cq, unsigned int desc_count,
+       unsigned int desc_size)
+{
+       int mem_size;
+
+       mem_size = vnic_dev_desc_ring_size(&cq->ring, desc_count, desc_size);
+
+       return mem_size;
+}
+
+void vnic_cq_free(struct vnic_cq *cq)
+{
+       vnic_dev_free_desc_ring(cq->vdev, &cq->ring);
+
+       cq->ctrl = NULL;
+}
+
+int vnic_cq_alloc(struct vnic_dev *vdev, struct vnic_cq *cq, unsigned int index,
+       unsigned int socket_id,
+       unsigned int desc_count, unsigned int desc_size)
+{
+       int err;
+       char res_name[NAME_MAX];
+       static int instance;
+
+       cq->index = index;
+       cq->vdev = vdev;
+
+       cq->ctrl = vnic_dev_get_res(vdev, RES_TYPE_CQ, index);
+       if (!cq->ctrl) {
+               pr_err("Failed to hook CQ[%d] resource\n", index);
+               return -EINVAL;
+       }
+
+       snprintf(res_name, sizeof(res_name), "%d-cq-%d", instance++, index);
+       err = vnic_dev_alloc_desc_ring(vdev, &cq->ring, desc_count, desc_size,
+               socket_id, res_name);
+       if (err)
+               return err;
+
+       return 0;
+}
+
+void vnic_cq_init(struct vnic_cq *cq, unsigned int flow_control_enable,
+       unsigned int color_enable, unsigned int cq_head, unsigned int cq_tail,
+       unsigned int cq_tail_color, unsigned int interrupt_enable,
+       unsigned int cq_entry_enable, unsigned int cq_message_enable,
+       unsigned int interrupt_offset, u64 cq_message_addr)
+{
+       u64 paddr;
+
+       paddr = (u64)cq->ring.base_addr | VNIC_PADDR_TARGET;
+       writeq(paddr, &cq->ctrl->ring_base);
+       iowrite32(cq->ring.desc_count, &cq->ctrl->ring_size);
+       iowrite32(flow_control_enable, &cq->ctrl->flow_control_enable);
+       iowrite32(color_enable, &cq->ctrl->color_enable);
+       iowrite32(cq_head, &cq->ctrl->cq_head);
+       iowrite32(cq_tail, &cq->ctrl->cq_tail);
+       iowrite32(cq_tail_color, &cq->ctrl->cq_tail_color);
+       iowrite32(interrupt_enable, &cq->ctrl->interrupt_enable);
+       iowrite32(cq_entry_enable, &cq->ctrl->cq_entry_enable);
+       iowrite32(cq_message_enable, &cq->ctrl->cq_message_enable);
+       iowrite32(interrupt_offset, &cq->ctrl->interrupt_offset);
+       writeq(cq_message_addr, &cq->ctrl->cq_message_addr);
+
+       cq->interrupt_offset = interrupt_offset;
+}
+
+void vnic_cq_clean(struct vnic_cq *cq)
+{
+       cq->to_clean = 0;
+       cq->last_color = 0;
+
+       iowrite32(0, &cq->ctrl->cq_head);
+       iowrite32(0, &cq->ctrl->cq_tail);
+       iowrite32(1, &cq->ctrl->cq_tail_color);
+
+       vnic_dev_clear_desc_ring(&cq->ring);
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_cq.h b/lib/librte_pmd_enic/vnic/vnic_cq.h
new file mode 100644 (file)
index 0000000..9ed9b1d
--- /dev/null
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_cq.h 173398 2014-05-19 09:17:02Z gvaradar $"
+
+#ifndef _VNIC_CQ_H_
+#define _VNIC_CQ_H_
+
+#include <rte_mbuf.h>
+
+#include "cq_desc.h"
+#include "vnic_dev.h"
+
+/* Completion queue control */
+struct vnic_cq_ctrl {
+       u64 ring_base;                  /* 0x00 */
+       u32 ring_size;                  /* 0x08 */
+       u32 pad0;
+       u32 flow_control_enable;        /* 0x10 */
+       u32 pad1;
+       u32 color_enable;               /* 0x18 */
+       u32 pad2;
+       u32 cq_head;                    /* 0x20 */
+       u32 pad3;
+       u32 cq_tail;                    /* 0x28 */
+       u32 pad4;
+       u32 cq_tail_color;              /* 0x30 */
+       u32 pad5;
+       u32 interrupt_enable;           /* 0x38 */
+       u32 pad6;
+       u32 cq_entry_enable;            /* 0x40 */
+       u32 pad7;
+       u32 cq_message_enable;          /* 0x48 */
+       u32 pad8;
+       u32 interrupt_offset;           /* 0x50 */
+       u32 pad9;
+       u64 cq_message_addr;            /* 0x58 */
+       u32 pad10;
+};
+
+#ifdef ENIC_AIC
+struct vnic_rx_bytes_counter {
+       unsigned int small_pkt_bytes_cnt;
+       unsigned int large_pkt_bytes_cnt;
+};
+#endif
+
+struct vnic_cq {
+       unsigned int index;
+       struct vnic_dev *vdev;
+       struct vnic_cq_ctrl __iomem *ctrl;              /* memory-mapped */
+       struct vnic_dev_ring ring;
+       unsigned int to_clean;
+       unsigned int last_color;
+       unsigned int interrupt_offset;
+#ifdef ENIC_AIC
+       struct vnic_rx_bytes_counter pkt_size_counter;
+       unsigned int cur_rx_coal_timeval;
+       unsigned int tobe_rx_coal_timeval;
+       ktime_t prev_ts;
+#endif
+};
+
+static inline unsigned int vnic_cq_service(struct vnic_cq *cq,
+       unsigned int work_to_do,
+       int (*q_service)(struct vnic_dev *vdev, struct cq_desc *cq_desc,
+       u8 type, u16 q_number, u16 completed_index, void *opaque),
+       void *opaque)
+{
+       struct cq_desc *cq_desc;
+       unsigned int work_done = 0;
+       u16 q_number, completed_index;
+       u8 type, color;
+       struct rte_mbuf **rx_pkts = opaque;
+       unsigned int ret;
+       unsigned int split_hdr_size = vnic_get_hdr_split_size(cq->vdev);
+
+       cq_desc = (struct cq_desc *)((u8 *)cq->ring.descs +
+               cq->ring.desc_size * cq->to_clean);
+       cq_desc_dec(cq_desc, &type, &color,
+               &q_number, &completed_index);
+
+       while (color != cq->last_color) {
+               if (opaque)
+                       opaque = (void *)&(rx_pkts[work_done]);
+
+               ret = (*q_service)(cq->vdev, cq_desc, type,
+                       q_number, completed_index, opaque);
+               cq->to_clean++;
+               if (cq->to_clean == cq->ring.desc_count) {
+                       cq->to_clean = 0;
+                       cq->last_color = cq->last_color ? 0 : 1;
+               }
+
+               cq_desc = (struct cq_desc *)((u8 *)cq->ring.descs +
+                       cq->ring.desc_size * cq->to_clean);
+               cq_desc_dec(cq_desc, &type, &color,
+                       &q_number, &completed_index);
+
+               if (ret)
+                       work_done++;
+               if (work_done >= work_to_do)
+                       break;
+       }
+
+       return work_done;
+}
+
+void vnic_cq_free(struct vnic_cq *cq);
+int vnic_cq_alloc(struct vnic_dev *vdev, struct vnic_cq *cq, unsigned int index,
+       unsigned int socket_id,
+       unsigned int desc_count, unsigned int desc_size);
+void vnic_cq_init(struct vnic_cq *cq, unsigned int flow_control_enable,
+       unsigned int color_enable, unsigned int cq_head, unsigned int cq_tail,
+       unsigned int cq_tail_color, unsigned int interrupt_enable,
+       unsigned int cq_entry_enable, unsigned int message_enable,
+       unsigned int interrupt_offset, u64 message_addr);
+void vnic_cq_clean(struct vnic_cq *cq);
+int vnic_cq_mem_size(struct vnic_cq *cq, unsigned int desc_count,
+       unsigned int desc_size);
+
+#endif /* _VNIC_CQ_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_dev.c b/lib/librte_pmd_enic/vnic/vnic_dev.c
new file mode 100644 (file)
index 0000000..485123f
--- /dev/null
@@ -0,0 +1,1063 @@
+/*
+ * Copyright 2008-2014 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id$"
+
+#include <rte_memzone.h>
+#include <rte_memcpy.h>
+#include <rte_string_fns.h>
+
+#include "vnic_dev.h"
+#include "vnic_resource.h"
+#include "vnic_devcmd.h"
+#include "vnic_stats.h"
+
+
+enum vnic_proxy_type {
+       PROXY_NONE,
+       PROXY_BY_BDF,
+       PROXY_BY_INDEX,
+};
+
+struct vnic_res {
+       void __iomem *vaddr;
+       dma_addr_t bus_addr;
+       unsigned int count;
+};
+
+struct vnic_intr_coal_timer_info {
+       u32 mul;
+       u32 div;
+       u32 max_usec;
+};
+
+struct vnic_dev {
+       void *priv;
+       struct rte_pci_device *pdev;
+       struct vnic_res res[RES_TYPE_MAX];
+       enum vnic_dev_intr_mode intr_mode;
+       struct vnic_devcmd __iomem *devcmd;
+       struct vnic_devcmd_notify *notify;
+       struct vnic_devcmd_notify notify_copy;
+       dma_addr_t notify_pa;
+       u32 notify_sz;
+       dma_addr_t linkstatus_pa;
+       struct vnic_stats *stats;
+       dma_addr_t stats_pa;
+       struct vnic_devcmd_fw_info *fw_info;
+       dma_addr_t fw_info_pa;
+       enum vnic_proxy_type proxy;
+       u32 proxy_index;
+       u64 args[VNIC_DEVCMD_NARGS];
+       u16 split_hdr_size;
+       int in_reset;
+       struct vnic_intr_coal_timer_info intr_coal_timer_info;
+       void *(*alloc_consistent)(void *priv, size_t size,
+               dma_addr_t *dma_handle, u8 *name);
+       void (*free_consistent)(struct rte_pci_device *hwdev,
+               size_t size, void *vaddr,
+               dma_addr_t dma_handle);
+};
+
+#define VNIC_MAX_RES_HDR_SIZE \
+       (sizeof(struct vnic_resource_header) + \
+       sizeof(struct vnic_resource) * RES_TYPE_MAX)
+#define VNIC_RES_STRIDE        128
+
+void *vnic_dev_priv(struct vnic_dev *vdev)
+{
+       return vdev->priv;
+}
+
+void vnic_register_cbacks(struct vnic_dev *vdev,
+       void *(*alloc_consistent)(void *priv, size_t size,
+           dma_addr_t *dma_handle, u8 *name),
+       void (*free_consistent)(struct rte_pci_device *hwdev,
+           size_t size, void *vaddr,
+           dma_addr_t dma_handle))
+{
+       vdev->alloc_consistent = alloc_consistent;
+       vdev->free_consistent = free_consistent;
+}
+
+static int vnic_dev_discover_res(struct vnic_dev *vdev,
+       struct vnic_dev_bar *bar, unsigned int num_bars)
+{
+       struct vnic_resource_header __iomem *rh;
+       struct mgmt_barmap_hdr __iomem *mrh;
+       struct vnic_resource __iomem *r;
+       u8 type;
+
+       if (num_bars == 0)
+               return -EINVAL;
+
+       if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
+               pr_err("vNIC BAR0 res hdr length error\n");
+               return -EINVAL;
+       }
+
+       rh  = bar->vaddr;
+       mrh = bar->vaddr;
+       if (!rh) {
+               pr_err("vNIC BAR0 res hdr not mem-mapped\n");
+               return -EINVAL;
+       }
+
+       /* Check for mgmt vnic in addition to normal vnic */
+       if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) ||
+               (ioread32(&rh->version) != VNIC_RES_VERSION)) {
+               if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) ||
+                       (ioread32(&mrh->version) != MGMTVNIC_VERSION)) {
+                       pr_err("vNIC BAR0 res magic/version error " \
+                               "exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n",
+                               VNIC_RES_MAGIC, VNIC_RES_VERSION,
+                               MGMTVNIC_MAGIC, MGMTVNIC_VERSION,
+                               ioread32(&rh->magic), ioread32(&rh->version));
+                       return -EINVAL;
+               }
+       }
+
+       if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC)
+               r = (struct vnic_resource __iomem *)(mrh + 1);
+       else
+               r = (struct vnic_resource __iomem *)(rh + 1);
+
+
+       while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
+               u8 bar_num = ioread8(&r->bar);
+               u32 bar_offset = ioread32(&r->bar_offset);
+               u32 count = ioread32(&r->count);
+               u32 len;
+
+               r++;
+
+               if (bar_num >= num_bars)
+                       continue;
+
+               if (!bar[bar_num].len || !bar[bar_num].vaddr)
+                       continue;
+
+               switch (type) {
+               case RES_TYPE_WQ:
+               case RES_TYPE_RQ:
+               case RES_TYPE_CQ:
+               case RES_TYPE_INTR_CTRL:
+                       /* each count is stride bytes long */
+                       len = count * VNIC_RES_STRIDE;
+                       if (len + bar_offset > bar[bar_num].len) {
+                               pr_err("vNIC BAR0 resource %d " \
+                                       "out-of-bounds, offset 0x%x + " \
+                                       "size 0x%x > bar len 0x%lx\n",
+                                       type, bar_offset,
+                                       len,
+                                       bar[bar_num].len);
+                               return -EINVAL;
+                       }
+                       break;
+               case RES_TYPE_INTR_PBA_LEGACY:
+               case RES_TYPE_DEVCMD:
+                       len = count;
+                       break;
+               default:
+                       continue;
+               }
+
+               vdev->res[type].count = count;
+               vdev->res[type].vaddr = (char __iomem *)bar[bar_num].vaddr +
+                   bar_offset;
+               vdev->res[type].bus_addr = bar[bar_num].bus_addr + bar_offset;
+       }
+
+       return 0;
+}
+
+unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
+       enum vnic_res_type type)
+{
+       return vdev->res[type].count;
+}
+
+void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
+       unsigned int index)
+{
+       if (!vdev->res[type].vaddr)
+               return NULL;
+
+       switch (type) {
+       case RES_TYPE_WQ:
+       case RES_TYPE_RQ:
+       case RES_TYPE_CQ:
+       case RES_TYPE_INTR_CTRL:
+               return (char __iomem *)vdev->res[type].vaddr +
+                       index * VNIC_RES_STRIDE;
+       default:
+               return (char __iomem *)vdev->res[type].vaddr;
+       }
+}
+
+unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
+       unsigned int desc_count, unsigned int desc_size)
+{
+       /* The base address of the desc rings must be 512 byte aligned.
+        * Descriptor count is aligned to groups of 32 descriptors.  A
+        * count of 0 means the maximum 4096 descriptors.  Descriptor
+        * size is aligned to 16 bytes.
+        */
+
+       unsigned int count_align = 32;
+       unsigned int desc_align = 16;
+
+       ring->base_align = 512;
+
+       if (desc_count == 0)
+               desc_count = 4096;
+
+       ring->desc_count = ALIGN(desc_count, count_align);
+
+       ring->desc_size = ALIGN(desc_size, desc_align);
+
+       ring->size = ring->desc_count * ring->desc_size;
+       ring->size_unaligned = ring->size + ring->base_align;
+
+       return ring->size_unaligned;
+}
+
+void vnic_set_hdr_split_size(struct vnic_dev *vdev, u16 size)
+{
+       vdev->split_hdr_size = size;
+}
+
+u16 vnic_get_hdr_split_size(struct vnic_dev *vdev)
+{
+       return vdev->split_hdr_size;
+}
+
+void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
+{
+       memset(ring->descs, 0, ring->size);
+}
+
+int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
+       unsigned int desc_count, unsigned int desc_size, unsigned int socket_id,
+       char *z_name)
+{
+       const struct rte_memzone *rz;
+
+       vnic_dev_desc_ring_size(ring, desc_count, desc_size);
+
+       rz = rte_memzone_reserve_aligned(z_name,
+               ring->size_unaligned, socket_id,
+               0, ENIC_ALIGN);
+       if (!rz) {
+               pr_err("Failed to allocate ring (size=%d), aborting\n",
+                       (int)ring->size);
+               return -ENOMEM;
+       }
+
+       ring->descs_unaligned = rz->addr;
+       if (!ring->descs_unaligned) {
+               pr_err("Failed to map allocated ring (size=%d), aborting\n",
+                       (int)ring->size);
+               return -ENOMEM;
+       }
+
+       ring->base_addr_unaligned = (dma_addr_t)rz->phys_addr;
+
+       ring->base_addr = ALIGN(ring->base_addr_unaligned,
+               ring->base_align);
+       ring->descs = (u8 *)ring->descs_unaligned +
+           (ring->base_addr - ring->base_addr_unaligned);
+
+       vnic_dev_clear_desc_ring(ring);
+
+       ring->desc_avail = ring->desc_count - 1;
+
+       return 0;
+}
+
+void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring)
+{
+       if (ring->descs)
+               ring->descs = NULL;
+}
+
+static int _vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+       int wait)
+{
+       struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
+       unsigned int i;
+       int delay;
+       u32 status;
+       int err;
+
+       status = ioread32(&devcmd->status);
+       if (status == 0xFFFFFFFF) {
+               /* PCI-e target device is gone */
+               return -ENODEV;
+       }
+       if (status & STAT_BUSY) {
+
+               pr_err("Busy devcmd %d\n",  _CMD_N(cmd));
+               return -EBUSY;
+       }
+
+       if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
+               for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
+                       writeq(vdev->args[i], &devcmd->args[i]);
+               wmb(); /* complete all writes initiated till now */
+       }
+
+       iowrite32(cmd, &devcmd->cmd);
+
+       if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
+               return 0;
+
+       for (delay = 0; delay < wait; delay++) {
+
+               udelay(100);
+
+               status = ioread32(&devcmd->status);
+               if (status == 0xFFFFFFFF) {
+                       /* PCI-e target device is gone */
+                       return -ENODEV;
+               }
+
+               if (!(status & STAT_BUSY)) {
+                       if (status & STAT_ERROR) {
+                               err = -(int)readq(&devcmd->args[0]);
+                               if (cmd != CMD_CAPABILITY)
+                                       pr_err("Devcmd %d failed " \
+                                               "with error code %d\n",
+                                               _CMD_N(cmd), err);
+                               return err;
+                       }
+
+                       if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
+                               rmb();/* finish all reads initiated till now */
+                               for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
+                                       vdev->args[i] = readq(&devcmd->args[i]);
+                       }
+
+                       return 0;
+               }
+       }
+
+       pr_err("Timedout devcmd %d\n", _CMD_N(cmd));
+       return -ETIMEDOUT;
+}
+
+static int vnic_dev_cmd_proxy(struct vnic_dev *vdev,
+       enum vnic_devcmd_cmd proxy_cmd, enum vnic_devcmd_cmd cmd,
+       u64 *a0, u64 *a1, int wait)
+{
+       u32 status;
+       int err;
+
+       memset(vdev->args, 0, sizeof(vdev->args));
+
+       vdev->args[0] = vdev->proxy_index;
+       vdev->args[1] = cmd;
+       vdev->args[2] = *a0;
+       vdev->args[3] = *a1;
+
+       err = _vnic_dev_cmd(vdev, proxy_cmd, wait);
+       if (err)
+               return err;
+
+       status = (u32)vdev->args[0];
+       if (status & STAT_ERROR) {
+               err = (int)vdev->args[1];
+               if (err != ERR_ECMDUNKNOWN ||
+                   cmd != CMD_CAPABILITY)
+                       pr_err("Error %d proxy devcmd %d\n", err, _CMD_N(cmd));
+               return err;
+       }
+
+       *a0 = vdev->args[1];
+       *a1 = vdev->args[2];
+
+       return 0;
+}
+
+static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev,
+       enum vnic_devcmd_cmd cmd, u64 *a0, u64 *a1, int wait)
+{
+       int err;
+
+       vdev->args[0] = *a0;
+       vdev->args[1] = *a1;
+
+       err = _vnic_dev_cmd(vdev, cmd, wait);
+
+       *a0 = vdev->args[0];
+       *a1 = vdev->args[1];
+
+       return err;
+}
+
+void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev *vdev, u16 index)
+{
+       vdev->proxy = PROXY_BY_INDEX;
+       vdev->proxy_index = index;
+}
+
+void vnic_dev_cmd_proxy_by_bdf_start(struct vnic_dev *vdev, u16 bdf)
+{
+       vdev->proxy = PROXY_BY_BDF;
+       vdev->proxy_index = bdf;
+}
+
+void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev)
+{
+       vdev->proxy = PROXY_NONE;
+       vdev->proxy_index = 0;
+}
+
+int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+       u64 *a0, u64 *a1, int wait)
+{
+       memset(vdev->args, 0, sizeof(vdev->args));
+
+       switch (vdev->proxy) {
+       case PROXY_BY_INDEX:
+               return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd,
+                               a0, a1, wait);
+       case PROXY_BY_BDF:
+               return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd,
+                               a0, a1, wait);
+       case PROXY_NONE:
+       default:
+               return vnic_dev_cmd_no_proxy(vdev, cmd, a0, a1, wait);
+       }
+}
+
+static int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd)
+{
+       u64 a0 = (u32)cmd, a1 = 0;
+       int wait = 1000;
+       int err;
+
+       err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
+
+       return !(err || a0);
+}
+
+int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
+       void *value)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       int err;
+
+       a0 = offset;
+       a1 = size;
+
+       err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
+
+       switch (size) {
+       case 1:
+               *(u8 *)value = (u8)a0;
+               break;
+       case 2:
+               *(u16 *)value = (u16)a0;
+               break;
+       case 4:
+               *(u32 *)value = (u32)a0;
+               break;
+       case 8:
+               *(u64 *)value = a0;
+               break;
+       default:
+               BUG();
+               break;
+       }
+
+       return err;
+}
+
+int vnic_dev_stats_clear(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
+}
+
+int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       static instance;
+       char name[NAME_MAX];
+
+       if (!vdev->stats) {
+               snprintf(name, sizeof(name), "vnic_stats-%d", instance++);
+               vdev->stats = vdev->alloc_consistent(vdev->priv,
+                       sizeof(struct vnic_stats), &vdev->stats_pa, name);
+               if (!vdev->stats)
+                       return -ENOMEM;
+       }
+
+       *stats = vdev->stats;
+       a0 = vdev->stats_pa;
+       a1 = sizeof(struct vnic_stats);
+
+       return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
+}
+
+int vnic_dev_close(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
+}
+
+/** Deprecated.  @see vnic_dev_enable_wait */
+int vnic_dev_enable(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
+}
+
+int vnic_dev_enable_wait(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       if (vnic_dev_capable(vdev, CMD_ENABLE_WAIT))
+               return vnic_dev_cmd(vdev, CMD_ENABLE_WAIT, &a0, &a1, wait);
+       else
+               return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
+}
+
+int vnic_dev_disable(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
+}
+
+int vnic_dev_open(struct vnic_dev *vdev, int arg)
+{
+       u64 a0 = (u32)arg, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
+}
+
+int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+       int err;
+
+       *done = 0;
+
+       err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
+       if (err)
+               return err;
+
+       *done = (a0 == 0);
+
+       return 0;
+}
+
+int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
+{
+       u64 a0 = (u32)arg, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
+}
+
+int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+       int err;
+
+       *done = 0;
+
+       err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait);
+       if (err)
+               return err;
+
+       *done = (a0 == 0);
+
+       return 0;
+}
+
+int vnic_dev_get_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       int err, i;
+
+       for (i = 0; i < ETH_ALEN; i++)
+               mac_addr[i] = 0;
+
+       err = vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
+       if (err)
+               return err;
+
+       for (i = 0; i < ETH_ALEN; i++)
+               mac_addr[i] = ((u8 *)&a0)[i];
+
+       return 0;
+}
+
+int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
+       int broadcast, int promisc, int allmulti)
+{
+       u64 a0, a1 = 0;
+       int wait = 1000;
+       int err;
+
+       a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
+            (multicast ? CMD_PFILTER_MULTICAST : 0) |
+            (broadcast ? CMD_PFILTER_BROADCAST : 0) |
+            (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
+            (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
+
+       err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
+       if (err)
+               pr_err("Can't set packet filter\n");
+
+       return err;
+}
+
+int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+       int err;
+       int i;
+
+       for (i = 0; i < ETH_ALEN; i++)
+               ((u8 *)&a0)[i] = addr[i];
+
+       err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
+       if (err)
+               pr_err("Can't add addr [%02x:%02x:%02x:%02x:%02x:%02x], %d\n",
+                       addr[0], addr[1], addr[2], addr[3], addr[4], addr[5],
+                       err);
+
+       return err;
+}
+
+int vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+       int err;
+       int i;
+
+       for (i = 0; i < ETH_ALEN; i++)
+               ((u8 *)&a0)[i] = addr[i];
+
+       err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
+       if (err)
+               pr_err("Can't del addr [%02x:%02x:%02x:%02x:%02x:%02x], %d\n",
+                       addr[0], addr[1], addr[2], addr[3], addr[4], addr[5],
+                       err);
+
+       return err;
+}
+
+int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
+       u8 ig_vlan_rewrite_mode)
+{
+       u64 a0 = ig_vlan_rewrite_mode, a1 = 0;
+       int wait = 1000;
+
+       if (vnic_dev_capable(vdev, CMD_IG_VLAN_REWRITE_MODE))
+               return vnic_dev_cmd(vdev, CMD_IG_VLAN_REWRITE_MODE,
+                               &a0, &a1, wait);
+       else
+               return 0;
+}
+
+int vnic_dev_raise_intr(struct vnic_dev *vdev, u16 intr)
+{
+       u64 a0 = intr, a1 = 0;
+       int wait = 1000;
+       int err;
+
+       err = vnic_dev_cmd(vdev, CMD_IAR, &a0, &a1, wait);
+       if (err)
+               pr_err("Failed to raise INTR[%d], err %d\n", intr, err);
+
+       return err;
+}
+
+void vnic_dev_set_reset_flag(struct vnic_dev *vdev, int state)
+{
+       vdev->in_reset = state;
+}
+
+static inline int vnic_dev_in_reset(struct vnic_dev *vdev)
+{
+       return vdev->in_reset;
+}
+
+int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
+       void *notify_addr, dma_addr_t notify_pa, u16 intr)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       int r;
+
+       memset(notify_addr, 0, sizeof(struct vnic_devcmd_notify));
+       if (!vnic_dev_in_reset(vdev)) {
+               vdev->notify = notify_addr;
+               vdev->notify_pa = notify_pa;
+       }
+
+       a0 = (u64)notify_pa;
+       a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL;
+       a1 += sizeof(struct vnic_devcmd_notify);
+
+       r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
+       if (!vnic_dev_in_reset(vdev))
+               vdev->notify_sz = (r == 0) ? (u32)a1 : 0;
+
+       return r;
+}
+
+int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
+{
+       void *notify_addr;
+       dma_addr_t notify_pa;
+       char name[NAME_MAX];
+       static int instance;
+
+       if (vdev->notify || vdev->notify_pa) {
+               pr_warn("notify block %p still allocated.\n" \
+                       "Ignore if restarting port\n", vdev->notify);
+               return -EINVAL;
+       }
+
+       if (!vnic_dev_in_reset(vdev)) {
+               snprintf(name, sizeof(name), "vnic_notify-%d", instance++);
+               notify_addr = vdev->alloc_consistent(vdev->priv,
+                       sizeof(struct vnic_devcmd_notify),
+                       &notify_pa, name);
+               if (!notify_addr)
+                       return -ENOMEM;
+       }
+
+       return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr);
+}
+
+int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       int err;
+
+       a0 = 0;  /* paddr = 0 to unset notify buffer */
+       a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
+       a1 += sizeof(struct vnic_devcmd_notify);
+
+       err = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
+       if (!vnic_dev_in_reset(vdev)) {
+               vdev->notify = NULL;
+               vdev->notify_pa = 0;
+               vdev->notify_sz = 0;
+       }
+
+       return err;
+}
+
+int vnic_dev_notify_unset(struct vnic_dev *vdev)
+{
+       if (vdev->notify && !vnic_dev_in_reset(vdev)) {
+               vdev->free_consistent(vdev->pdev,
+                       sizeof(struct vnic_devcmd_notify),
+                       vdev->notify,
+                       vdev->notify_pa);
+       }
+
+       return vnic_dev_notify_unsetcmd(vdev);
+}
+
+static int vnic_dev_notify_ready(struct vnic_dev *vdev)
+{
+       u32 *words;
+       unsigned int nwords = vdev->notify_sz / 4;
+       unsigned int i;
+       u32 csum;
+
+       if (!vdev->notify || !vdev->notify_sz)
+               return 0;
+
+       do {
+               csum = 0;
+               rte_memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz);
+               words = (u32 *)&vdev->notify_copy;
+               for (i = 1; i < nwords; i++)
+                       csum += words[i];
+       } while (csum != words[0]);
+
+       return 1;
+}
+
+int vnic_dev_init(struct vnic_dev *vdev, int arg)
+{
+       u64 a0 = (u32)arg, a1 = 0;
+       int wait = 1000;
+       int r = 0;
+
+       if (vnic_dev_capable(vdev, CMD_INIT))
+               r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
+       else {
+               vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait);
+               if (a0 & CMD_INITF_DEFAULT_MAC) {
+                       /* Emulate these for old CMD_INIT_v1 which
+                        * didn't pass a0 so no CMD_INITF_*.
+                        */
+                       vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
+                       vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
+               }
+       }
+       return r;
+}
+
+int vnic_dev_deinit(struct vnic_dev *vdev)
+{
+       u64 a0 = 0, a1 = 0;
+       int wait = 1000;
+
+       return vnic_dev_cmd(vdev, CMD_DEINIT, &a0, &a1, wait);
+}
+
+void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev)
+{
+       /* Default: hardware intr coal timer is in units of 1.5 usecs */
+       vdev->intr_coal_timer_info.mul = 2;
+       vdev->intr_coal_timer_info.div = 3;
+       vdev->intr_coal_timer_info.max_usec =
+               vnic_dev_intr_coal_timer_hw_to_usec(vdev, 0xffff);
+}
+
+int vnic_dev_link_status(struct vnic_dev *vdev)
+{
+       if (!vnic_dev_notify_ready(vdev))
+               return 0;
+
+       return vdev->notify_copy.link_state;
+}
+
+u32 vnic_dev_port_speed(struct vnic_dev *vdev)
+{
+       if (!vnic_dev_notify_ready(vdev))
+               return 0;
+
+       return vdev->notify_copy.port_speed;
+}
+
+void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
+       enum vnic_dev_intr_mode intr_mode)
+{
+       vdev->intr_mode = intr_mode;
+}
+
+enum vnic_dev_intr_mode vnic_dev_get_intr_mode(
+       struct vnic_dev *vdev)
+{
+       return vdev->intr_mode;
+}
+
+u32 vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev, u32 usec)
+{
+       return (usec * vdev->intr_coal_timer_info.mul) /
+               vdev->intr_coal_timer_info.div;
+}
+
+u32 vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev, u32 hw_cycles)
+{
+       return (hw_cycles * vdev->intr_coal_timer_info.div) /
+               vdev->intr_coal_timer_info.mul;
+}
+
+u32 vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev)
+{
+       return vdev->intr_coal_timer_info.max_usec;
+}
+
+void vnic_dev_unregister(struct vnic_dev *vdev)
+{
+       if (vdev) {
+               if (vdev->notify)
+                       vdev->free_consistent(vdev->pdev,
+                               sizeof(struct vnic_devcmd_notify),
+                               vdev->notify,
+                               vdev->notify_pa);
+               if (vdev->stats)
+                       vdev->free_consistent(vdev->pdev,
+                               sizeof(struct vnic_stats),
+                               vdev->stats, vdev->stats_pa);
+               if (vdev->fw_info)
+                       vdev->free_consistent(vdev->pdev,
+                               sizeof(struct vnic_devcmd_fw_info),
+                               vdev->fw_info, vdev->fw_info_pa);
+               kfree(vdev);
+       }
+}
+
+struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
+       void *priv, struct rte_pci_device *pdev, struct vnic_dev_bar *bar,
+       unsigned int num_bars)
+{
+       if (!vdev) {
+               vdev = kzalloc(sizeof(struct vnic_dev), GFP_ATOMIC);
+               if (!vdev)
+                       return NULL;
+       }
+
+       vdev->priv = priv;
+       vdev->pdev = pdev;
+
+       if (vnic_dev_discover_res(vdev, bar, num_bars))
+               goto err_out;
+
+       vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
+       if (!vdev->devcmd)
+               goto err_out;
+
+       return vdev;
+
+err_out:
+       vnic_dev_unregister(vdev);
+       return NULL;
+}
+
+struct rte_pci_device *vnic_dev_get_pdev(struct vnic_dev *vdev)
+{
+       return vdev->pdev;
+}
+
+static int vnic_dev_cmd_status(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+       int *status)
+{
+       u64 a0 = cmd, a1 = 0;
+       int wait = 1000;
+       int ret;
+
+       ret = vnic_dev_cmd(vdev, CMD_STATUS, &a0, &a1, wait);
+       if (!ret)
+               *status = (int)a0;
+
+       return ret;
+}
+
+int vnic_dev_set_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       int i;
+
+       for (i = 0; i < ETH_ALEN; i++)
+               ((u8 *)&a0)[i] = mac_addr[i];
+
+       return vnic_dev_cmd(vdev, CMD_SET_MAC_ADDR, &a0, &a1, wait);
+}
+
+/*
+ *  vnic_dev_classifier: Add/Delete classifier entries
+ *  @vdev: vdev of the device
+ *  @cmd: CLSF_ADD for Add filter
+ *        CLSF_DEL for Delete filter
+ *  @entry: In case of ADD filter, the caller passes the RQ number in this
+ *          variable.
+ *          This function stores the filter_id returned by the
+ *          firmware in the same variable before return;
+ *
+ *          In case of DEL filter, the caller passes the RQ number. Return
+ *          value is irrelevant.
+ * @data: filter data
+ */
+int vnic_dev_classifier(struct vnic_dev *vdev, u8 cmd, u16 *entry,
+       struct filter *data)
+{
+       u64 a0, a1;
+       int wait = 1000;
+       dma_addr_t tlv_pa;
+       int ret = -EINVAL;
+       struct filter_tlv *tlv, *tlv_va;
+       struct filter_action *action;
+       u64 tlv_size;
+       static unsigned int unique_id;
+       char z_name[RTE_MEMZONE_NAMESIZE];
+
+       if (cmd == CLSF_ADD) {
+               tlv_size = sizeof(struct filter) +
+                   sizeof(struct filter_action) +
+                   2*sizeof(struct filter_tlv);
+               snprintf(z_name, sizeof(z_name), "vnic_clsf_%d", unique_id++);
+               tlv_va = vdev->alloc_consistent(vdev->priv,
+                       tlv_size, &tlv_pa, z_name);
+               if (!tlv_va)
+                       return -ENOMEM;
+               tlv = tlv_va;
+               a0 = tlv_pa;
+               a1 = tlv_size;
+               memset(tlv, 0, tlv_size);
+               tlv->type = CLSF_TLV_FILTER;
+               tlv->length = sizeof(struct filter);
+               *(struct filter *)&tlv->val = *data;
+
+               tlv = (struct filter_tlv *)((char *)tlv +
+                                        sizeof(struct filter_tlv) +
+                                        sizeof(struct filter));
+
+               tlv->type = CLSF_TLV_ACTION;
+               tlv->length = sizeof(struct filter_action);
+               action = (struct filter_action *)&tlv->val;
+               action->type = FILTER_ACTION_RQ_STEERING;
+               action->u.rq_idx = *entry;
+
+               ret = vnic_dev_cmd(vdev, CMD_ADD_FILTER, &a0, &a1, wait);
+               *entry = (u16)a0;
+               vdev->free_consistent(vdev->pdev, tlv_size, tlv_va, tlv_pa);
+       } else if (cmd == CLSF_DEL) {
+               a0 = *entry;
+               ret = vnic_dev_cmd(vdev, CMD_DEL_FILTER, &a0, &a1, wait);
+       }
+
+       return ret;
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_dev.h b/lib/librte_pmd_enic/vnic/vnic_dev.h
new file mode 100644 (file)
index 0000000..63c26dd
--- /dev/null
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_dev.h 196958 2014-11-04 18:23:37Z xuywang $"
+
+#ifndef _VNIC_DEV_H_
+#define _VNIC_DEV_H_
+
+#include "enic_compat.h"
+#include "rte_pci.h"
+#include "vnic_resource.h"
+#include "vnic_devcmd.h"
+
+#ifndef VNIC_PADDR_TARGET
+#define VNIC_PADDR_TARGET      0x0000000000000000ULL
+#endif
+
+#ifndef readq
+static inline u64 readq(void __iomem *reg)
+{
+       return ((u64)readl(reg + 0x4UL) << 32) |
+               (u64)readl(reg);
+}
+
+static inline void writeq(u64 val, void __iomem *reg)
+{
+       writel(val & 0xffffffff, reg);
+       writel(val >> 32, reg + 0x4UL);
+}
+#endif
+
+#undef pr_fmt
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+enum vnic_dev_intr_mode {
+       VNIC_DEV_INTR_MODE_UNKNOWN,
+       VNIC_DEV_INTR_MODE_INTX,
+       VNIC_DEV_INTR_MODE_MSI,
+       VNIC_DEV_INTR_MODE_MSIX,
+};
+
+struct vnic_dev_bar {
+       void __iomem *vaddr;
+       dma_addr_t bus_addr;
+       unsigned long len;
+};
+
+struct vnic_dev_ring {
+       void *descs;
+       size_t size;
+       dma_addr_t base_addr;
+       size_t base_align;
+       void *descs_unaligned;
+       size_t size_unaligned;
+       dma_addr_t base_addr_unaligned;
+       unsigned int desc_size;
+       unsigned int desc_count;
+       unsigned int desc_avail;
+};
+
+struct vnic_dev_iomap_info {
+       dma_addr_t bus_addr;
+       unsigned long len;
+       void __iomem *vaddr;
+};
+
+struct vnic_dev;
+struct vnic_stats;
+
+void *vnic_dev_priv(struct vnic_dev *vdev);
+unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
+       enum vnic_res_type type);
+void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
+       unsigned int index);
+dma_addr_t vnic_dev_get_res_bus_addr(struct vnic_dev *vdev,
+       enum vnic_res_type type, unsigned int index);
+uint8_t vnic_dev_get_res_bar(struct vnic_dev *vdev,
+       enum vnic_res_type type);
+uint32_t vnic_dev_get_res_offset(struct vnic_dev *vdev,
+       enum vnic_res_type type, unsigned int index);
+unsigned long vnic_dev_get_res_type_len(struct vnic_dev *vdev,
+                                       enum vnic_res_type type);
+unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
+       unsigned int desc_count, unsigned int desc_size);
+void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring);
+int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
+       unsigned int desc_count, unsigned int desc_size, unsigned int socket_id,
+       char *z_name);
+void vnic_dev_free_desc_ring(struct vnic_dev *vdev,
+       struct vnic_dev_ring *ring);
+int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+       u64 *a0, u64 *a1, int wait);
+int vnic_dev_cmd_args(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+       u64 *args, int nargs, int wait);
+void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev *vdev, u16 index);
+void vnic_dev_cmd_proxy_by_bdf_start(struct vnic_dev *vdev, u16 bdf);
+void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev);
+int vnic_dev_fw_info(struct vnic_dev *vdev,
+       struct vnic_devcmd_fw_info **fw_info);
+int vnic_dev_asic_info(struct vnic_dev *vdev, u16 *asic_type, u16 *asic_rev);
+int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
+       void *value);
+int vnic_dev_stats_clear(struct vnic_dev *vdev);
+int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats);
+int vnic_dev_hang_notify(struct vnic_dev *vdev);
+int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
+       int broadcast, int promisc, int allmulti);
+int vnic_dev_packet_filter_all(struct vnic_dev *vdev, int directed,
+       int multicast, int broadcast, int promisc, int allmulti);
+int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr);
+int vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr);
+int vnic_dev_get_mac_addr(struct vnic_dev *vdev, u8 *mac_addr);
+int vnic_dev_raise_intr(struct vnic_dev *vdev, u16 intr);
+int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr);
+int vnic_dev_notify_unset(struct vnic_dev *vdev);
+int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
+       void *notify_addr, dma_addr_t notify_pa, u16 intr);
+int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev);
+int vnic_dev_link_status(struct vnic_dev *vdev);
+u32 vnic_dev_port_speed(struct vnic_dev *vdev);
+u32 vnic_dev_msg_lvl(struct vnic_dev *vdev);
+u32 vnic_dev_mtu(struct vnic_dev *vdev);
+u32 vnic_dev_link_down_cnt(struct vnic_dev *vdev);
+u32 vnic_dev_notify_status(struct vnic_dev *vdev);
+u32 vnic_dev_uif(struct vnic_dev *vdev);
+int vnic_dev_close(struct vnic_dev *vdev);
+int vnic_dev_enable(struct vnic_dev *vdev);
+int vnic_dev_enable_wait(struct vnic_dev *vdev);
+int vnic_dev_disable(struct vnic_dev *vdev);
+int vnic_dev_open(struct vnic_dev *vdev, int arg);
+int vnic_dev_open_done(struct vnic_dev *vdev, int *done);
+int vnic_dev_init(struct vnic_dev *vdev, int arg);
+int vnic_dev_init_done(struct vnic_dev *vdev, int *done, int *err);
+int vnic_dev_init_prov(struct vnic_dev *vdev, u8 *buf, u32 len);
+int vnic_dev_deinit(struct vnic_dev *vdev);
+void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev);
+int vnic_dev_intr_coal_timer_info(struct vnic_dev *vdev);
+int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg);
+int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done);
+int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg);
+int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done);
+void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
+       enum vnic_dev_intr_mode intr_mode);
+enum vnic_dev_intr_mode vnic_dev_get_intr_mode(struct vnic_dev *vdev);
+u32 vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev, u32 usec);
+u32 vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev, u32 hw_cycles);
+u32 vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev);
+void vnic_dev_unregister(struct vnic_dev *vdev);
+int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
+       u8 ig_vlan_rewrite_mode);
+struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
+       void *priv, struct rte_pci_device *pdev, struct vnic_dev_bar *bar,
+       unsigned int num_bars);
+struct rte_pci_device *vnic_dev_get_pdev(struct vnic_dev *vdev);
+int vnic_dev_cmd_init(struct vnic_dev *vdev, int fallback);
+int vnic_dev_get_size(void);
+int vnic_dev_int13(struct vnic_dev *vdev, u64 arg, u32 op);
+int vnic_dev_perbi(struct vnic_dev *vdev, u64 arg, u32 op);
+u32 vnic_dev_perbi_rebuild_cnt(struct vnic_dev *vdev);
+int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len);
+int vnic_dev_enable2(struct vnic_dev *vdev, int active);
+int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status);
+int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status);
+int vnic_dev_set_mac_addr(struct vnic_dev *vdev, u8 *mac_addr);
+int vnic_dev_classifier(struct vnic_dev *vdev, u8 cmd, u16 *entry,
+       struct filter *data);
+#ifdef ENIC_VXLAN
+int vnic_dev_overlay_offload_enable_disable(struct vnic_dev *vdev,
+       u8 overlay, u8 config);
+int vnic_dev_overlay_offload_cfg(struct vnic_dev *vdev, u8 overlay,
+       u16 vxlan_udp_port_number);
+#endif
+#endif /* _VNIC_DEV_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_devcmd.h b/lib/librte_pmd_enic/vnic/vnic_devcmd.h
new file mode 100644 (file)
index 0000000..b4c87c1
--- /dev/null
@@ -0,0 +1,774 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_devcmd.h 173135 2014-05-16 03:14:07Z sanpilla $"
+
+#ifndef _VNIC_DEVCMD_H_
+#define _VNIC_DEVCMD_H_
+
+#define _CMD_NBITS      14
+#define _CMD_VTYPEBITS 10
+#define _CMD_FLAGSBITS  6
+#define _CMD_DIRBITS   2
+
+#define _CMD_NMASK      ((1 << _CMD_NBITS)-1)
+#define _CMD_VTYPEMASK  ((1 << _CMD_VTYPEBITS)-1)
+#define _CMD_FLAGSMASK  ((1 << _CMD_FLAGSBITS)-1)
+#define _CMD_DIRMASK    ((1 << _CMD_DIRBITS)-1)
+
+#define _CMD_NSHIFT     0
+#define _CMD_VTYPESHIFT (_CMD_NSHIFT+_CMD_NBITS)
+#define _CMD_FLAGSSHIFT (_CMD_VTYPESHIFT+_CMD_VTYPEBITS)
+#define _CMD_DIRSHIFT   (_CMD_FLAGSSHIFT+_CMD_FLAGSBITS)
+
+/*
+ * Direction bits (from host perspective).
+ */
+#define _CMD_DIR_NONE   0U
+#define _CMD_DIR_WRITE  1U
+#define _CMD_DIR_READ   2U
+#define _CMD_DIR_RW     (_CMD_DIR_WRITE | _CMD_DIR_READ)
+
+/*
+ * Flag bits.
+ */
+#define _CMD_FLAGS_NONE 0U
+#define _CMD_FLAGS_NOWAIT 1U
+
+/*
+ * vNIC type bits.
+ */
+#define _CMD_VTYPE_NONE  0U
+#define _CMD_VTYPE_ENET  1U
+#define _CMD_VTYPE_FC    2U
+#define _CMD_VTYPE_SCSI  4U
+#define _CMD_VTYPE_ALL   (_CMD_VTYPE_ENET | _CMD_VTYPE_FC | _CMD_VTYPE_SCSI)
+
+/*
+ * Used to create cmds..
+ */
+#define _CMDCF(dir, flags, vtype, nr)  \
+       (((dir)   << _CMD_DIRSHIFT) | \
+       ((flags) << _CMD_FLAGSSHIFT) | \
+       ((vtype) << _CMD_VTYPESHIFT) | \
+       ((nr)    << _CMD_NSHIFT))
+#define _CMDC(dir, vtype, nr)    _CMDCF(dir, 0, vtype, nr)
+#define _CMDCNW(dir, vtype, nr)  _CMDCF(dir, _CMD_FLAGS_NOWAIT, vtype, nr)
+
+/*
+ * Used to decode cmds..
+ */
+#define _CMD_DIR(cmd)            (((cmd) >> _CMD_DIRSHIFT) & _CMD_DIRMASK)
+#define _CMD_FLAGS(cmd)          (((cmd) >> _CMD_FLAGSSHIFT) & _CMD_FLAGSMASK)
+#define _CMD_VTYPE(cmd)          (((cmd) >> _CMD_VTYPESHIFT) & _CMD_VTYPEMASK)
+#define _CMD_N(cmd)              (((cmd) >> _CMD_NSHIFT) & _CMD_NMASK)
+
+enum vnic_devcmd_cmd {
+       CMD_NONE                = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_NONE, 0),
+
+       /*
+        * mcpu fw info in mem:
+        * in:
+        *   (u64)a0=paddr to struct vnic_devcmd_fw_info
+        * action:
+        *   Fills in struct vnic_devcmd_fw_info (128 bytes)
+        * note:
+        *   An old definition of CMD_MCPU_FW_INFO
+        */
+       CMD_MCPU_FW_INFO_OLD    = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 1),
+
+       /*
+        * mcpu fw info in mem:
+        * in:
+        *   (u64)a0=paddr to struct vnic_devcmd_fw_info
+        *   (u16)a1=size of the structure
+        * out:
+        *       (u16)a1=0                          for in:a1 = 0,
+        *               data size actually written for other values.
+        * action:
+        *   Fills in first 128 bytes of vnic_devcmd_fw_info for in:a1 = 0,
+        *            first in:a1 bytes               for 0 < in:a1 <= 132,
+        *            132 bytes                       for other values of in:a1.
+        * note:
+        *   CMD_MCPU_FW_INFO and CMD_MCPU_FW_INFO_OLD have the same enum 1
+        *   for source compatibility.
+        */
+       CMD_MCPU_FW_INFO        = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 1),
+
+       /* dev-specific block member:
+        *    in: (u16)a0=offset,(u8)a1=size
+        *    out: a0=value */
+       CMD_DEV_SPEC            = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 2),
+
+       /* stats clear */
+       CMD_STATS_CLEAR         = _CMDCNW(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 3),
+
+       /* stats dump in mem: (u64)a0=paddr to stats area,
+        *                    (u16)a1=sizeof stats area */
+       CMD_STATS_DUMP          = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 4),
+
+       /* set Rx packet filter: (u32)a0=filters (see CMD_PFILTER_*) */
+       CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 7),
+
+       /* set Rx packet filter for all: (u32)a0=filters (see CMD_PFILTER_*) */
+       CMD_PACKET_FILTER_ALL   = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 7),
+
+       /* hang detection notification */
+       CMD_HANG_NOTIFY         = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 8),
+
+       /* MAC address in (u48)a0 */
+       CMD_GET_MAC_ADDR        = _CMDC(_CMD_DIR_READ,
+                                       _CMD_VTYPE_ENET | _CMD_VTYPE_FC, 9),
+
+       /* add addr from (u48)a0 */
+       CMD_ADDR_ADD            = _CMDCNW(_CMD_DIR_WRITE,
+                                       _CMD_VTYPE_ENET | _CMD_VTYPE_FC, 12),
+
+       /* del addr from (u48)a0 */
+       CMD_ADDR_DEL            = _CMDCNW(_CMD_DIR_WRITE,
+                                       _CMD_VTYPE_ENET | _CMD_VTYPE_FC, 13),
+
+       /* add VLAN id in (u16)a0 */
+       CMD_VLAN_ADD            = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 14),
+
+       /* del VLAN id in (u16)a0 */
+       CMD_VLAN_DEL            = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 15),
+
+       /* nic_cfg in (u32)a0 */
+       CMD_NIC_CFG             = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 16),
+
+       /* union vnic_rss_key in mem: (u64)a0=paddr, (u16)a1=len */
+       CMD_RSS_KEY             = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 17),
+
+       /* union vnic_rss_cpu in mem: (u64)a0=paddr, (u16)a1=len */
+       CMD_RSS_CPU             = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 18),
+
+       /* initiate softreset */
+       CMD_SOFT_RESET          = _CMDCNW(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 19),
+
+       /* softreset status:
+        *    out: a0=0 reset complete, a0=1 reset in progress */
+       CMD_SOFT_RESET_STATUS   = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 20),
+
+       /* set struct vnic_devcmd_notify buffer in mem:
+        * in:
+        *   (u64)a0=paddr to notify (set paddr=0 to unset)
+        *   (u32)a1 & 0x00000000ffffffff=sizeof(struct vnic_devcmd_notify)
+        *   (u16)a1 & 0x0000ffff00000000=intr num (-1 for no intr)
+        * out:
+        *   (u32)a1 = effective size
+        */
+       CMD_NOTIFY              = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 21),
+
+       /* UNDI API: (u64)a0=paddr to s_PXENV_UNDI_ struct,
+        *           (u8)a1=PXENV_UNDI_xxx */
+       CMD_UNDI                = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 22),
+
+       /* initiate open sequence (u32)a0=flags (see CMD_OPENF_*) */
+       CMD_OPEN                = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 23),
+
+       /* open status:
+        *    out: a0=0 open complete, a0=1 open in progress */
+       CMD_OPEN_STATUS         = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 24),
+
+       /* close vnic */
+       CMD_CLOSE               = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 25),
+
+       /* initialize virtual link: (u32)a0=flags (see CMD_INITF_*) */
+/***** Replaced by CMD_INIT *****/
+       CMD_INIT_v1             = _CMDCNW(_CMD_DIR_READ, _CMD_VTYPE_ALL, 26),
+
+       /* variant of CMD_INIT, with provisioning info
+        *     (u64)a0=paddr of vnic_devcmd_provinfo
+        *     (u32)a1=sizeof provision info */
+       CMD_INIT_PROV_INFO      = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 27),
+
+       /* enable virtual link */
+       CMD_ENABLE              = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 28),
+
+       /* enable virtual link, waiting variant. */
+       CMD_ENABLE_WAIT         = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 28),
+
+       /* disable virtual link */
+       CMD_DISABLE             = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 29),
+
+       /* stats dump sum of all vnic stats on same uplink in mem:
+        *     (u64)a0=paddr
+        *     (u16)a1=sizeof stats area */
+       CMD_STATS_DUMP_ALL      = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 30),
+
+       /* init status:
+        *    out: a0=0 init complete, a0=1 init in progress
+        *         if a0=0, a1=errno */
+       CMD_INIT_STATUS         = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 31),
+
+       /* INT13 API: (u64)a0=paddr to vnic_int13_params struct
+        *            (u32)a1=INT13_CMD_xxx */
+       CMD_INT13               = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_FC, 32),
+
+       /* logical uplink enable/disable: (u64)a0: 0/1=disable/enable */
+       CMD_LOGICAL_UPLINK      = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 33),
+
+       /* undo initialize of virtual link */
+       CMD_DEINIT              = _CMDCNW(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 34),
+
+       /* initialize virtual link: (u32)a0=flags (see CMD_INITF_*) */
+       CMD_INIT                = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 35),
+
+       /* check fw capability of a cmd:
+        * in:  (u32)a0=cmd
+        * out: (u32)a0=errno, 0:valid cmd, a1=supported VNIC_STF_* bits */
+       CMD_CAPABILITY          = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 36),
+
+       /* persistent binding info
+        * in:  (u64)a0=paddr of arg
+        *      (u32)a1=CMD_PERBI_XXX */
+       CMD_PERBI               = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_FC, 37),
+
+       /* Interrupt Assert Register functionality
+        * in: (u16)a0=interrupt number to assert
+        */
+       CMD_IAR                 = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 38),
+
+       /* initiate hangreset, like softreset after hang detected */
+       CMD_HANG_RESET          = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 39),
+
+       /* hangreset status:
+        *    out: a0=0 reset complete, a0=1 reset in progress */
+       CMD_HANG_RESET_STATUS   = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 40),
+
+       /*
+        * Set hw ingress packet vlan rewrite mode:
+        * in:  (u32)a0=new vlan rewrite mode
+        * out: (u32)a0=old vlan rewrite mode */
+       CMD_IG_VLAN_REWRITE_MODE = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ENET, 41),
+
+       /*
+        * in:  (u16)a0=bdf of target vnic
+        *      (u32)a1=cmd to proxy
+        *      a2-a15=args to cmd in a1
+        * out: (u32)a0=status of proxied cmd
+        *      a1-a15=out args of proxied cmd */
+       CMD_PROXY_BY_BDF =      _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 42),
+
+       /*
+        * As for BY_BDF except a0 is index of hvnlink subordinate vnic
+        * or SR-IOV virtual vnic
+        */
+       CMD_PROXY_BY_INDEX =    _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 43),
+
+       /*
+        * For HPP toggle:
+        * adapter-info-get
+        * in:  (u64)a0=phsical address of buffer passed in from caller.
+        *      (u16)a1=size of buffer specified in a0.
+        * out: (u64)a0=phsical address of buffer passed in from caller.
+        *      (u16)a1=actual bytes from VIF-CONFIG-INFO TLV, or
+        *              0 if no VIF-CONFIG-INFO TLV was ever received. */
+       CMD_CONFIG_INFO_GET = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 44),
+
+       /*
+        * INT13 API: (u64)a0=paddr to vnic_int13_params struct
+        *            (u32)a1=INT13_CMD_xxx
+        */
+       CMD_INT13_ALL = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 45),
+
+       /*
+        * Set default vlan:
+        * in: (u16)a0=new default vlan
+        *     (u16)a1=zero for overriding vlan with param a0,
+        *                     non-zero for resetting vlan to the default
+        * out: (u16)a0=old default vlan
+        */
+       CMD_SET_DEFAULT_VLAN = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 46),
+
+       /* init_prov_info2:
+        * Variant of CMD_INIT_PROV_INFO, where it will not try to enable
+        * the vnic until CMD_ENABLE2 is issued.
+        *     (u64)a0=paddr of vnic_devcmd_provinfo
+        *     (u32)a1=sizeof provision info */
+       CMD_INIT_PROV_INFO2  = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 47),
+
+       /* enable2:
+        *      (u32)a0=0                  ==> standby
+        *             =CMD_ENABLE2_ACTIVE ==> active
+        */
+       CMD_ENABLE2 = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 48),
+
+       /*
+        * cmd_status:
+        *     Returns the status of the specified command
+        * Input:
+        *     a0 = command for which status is being queried.
+        *          Possible values are:
+        *              CMD_SOFT_RESET
+        *              CMD_HANG_RESET
+        *              CMD_OPEN
+        *              CMD_INIT
+        *              CMD_INIT_PROV_INFO
+        *              CMD_DEINIT
+        *              CMD_INIT_PROV_INFO2
+        *              CMD_ENABLE2
+        * Output:
+        *     if status == STAT_ERROR
+        *        a0 = ERR_ENOTSUPPORTED - status for command in a0 is
+        *                                 not supported
+        *     if status == STAT_NONE
+        *        a0 = status of the devcmd specified in a0 as follows.
+        *             ERR_SUCCESS   - command in a0 completed successfully
+        *             ERR_EINPROGRESS - command in a0 is still in progress
+        */
+       CMD_STATUS = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 49),
+
+       /*
+        * Returns interrupt coalescing timer conversion factors.
+        * After calling this devcmd, ENIC driver can convert
+        * interrupt coalescing timer in usec into CPU cycles as follows:
+        *
+        *   intr_timer_cycles = intr_timer_usec * multiplier / divisor
+        *
+        * Interrupt coalescing timer in usecs can be be converted/obtained
+        * from CPU cycles as follows:
+        *
+        *   intr_timer_usec = intr_timer_cycles * divisor / multiplier
+        *
+        * in: none
+        * out: (u32)a0 = multiplier
+        *      (u32)a1 = divisor
+        *      (u32)a2 = maximum timer value in usec
+        */
+       CMD_INTR_COAL_CONVERT = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 50),
+
+       /*
+        * ISCSI DUMP API:
+        * in: (u64)a0=paddr of the param or param itself
+        *     (u32)a1=ISCSI_CMD_xxx
+        */
+       CMD_ISCSI_DUMP_REQ = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 51),
+
+       /*
+        * ISCSI DUMP STATUS API:
+        * in: (u32)a0=cmd tag
+        * in: (u32)a1=ISCSI_CMD_xxx
+        * out: (u32)a0=cmd status
+        */
+       CMD_ISCSI_DUMP_STATUS = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 52),
+
+       /*
+        * Subvnic migration from MQ <--> VF.
+        * Enable the LIF migration from MQ to VF and vice versa. MQ and VF
+        * indexes are statically bound at the time of initialization.
+        * Based on the
+        * direction of migration, the resources of either MQ or the VF shall
+        * be attached to the LIF.
+        * in:        (u32)a0=Direction of Migration
+        *                                      0=> Migrate to VF
+        *                                      1=> Migrate to MQ
+        *            (u32)a1=VF index (MQ index)
+        */
+       CMD_MIGRATE_SUBVNIC = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 53),
+
+
+       /*
+        * Register / Deregister the notification block for MQ subvnics
+        * in:
+        *   (u64)a0=paddr to notify (set paddr=0 to unset)
+        *   (u32)a1 & 0x00000000ffffffff=sizeof(struct vnic_devcmd_notify)
+        *   (u16)a1 & 0x0000ffff00000000=intr num (-1 for no intr)
+        * out:
+        *   (u32)a1 = effective size
+        */
+       CMD_SUBVNIC_NOTIFY = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 54),
+
+       /*
+        * Set the predefined mac address as default
+        * in:
+        *   (u48)a0=mac addr
+        */
+       CMD_SET_MAC_ADDR = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 55),
+
+       /* Update the provisioning info of the given VIF
+        *     (u64)a0=paddr of vnic_devcmd_provinfo
+        *     (u32)a1=sizeof provision info */
+       CMD_PROV_INFO_UPDATE = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 56),
+
+       /*
+        * Initialization for the devcmd2 interface.
+        * in: (u64) a0=host result buffer physical address
+        * in: (u16) a1=number of entries in result buffer
+        */
+       CMD_INITIALIZE_DEVCMD2 = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 57),
+
+       /*
+        * Add a filter.
+        * in: (u64) a0= filter address
+        *     (u32) a1= size of filter
+        * out: (u32) a0=filter identifier
+        */
+       CMD_ADD_FILTER = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ENET, 58),
+
+       /*
+        * Delete a filter.
+        * in: (u32) a0=filter identifier
+        */
+       CMD_DEL_FILTER = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 59),
+
+       /*
+        * Enable a Queue Pair in User space NIC
+        * in: (u32) a0=Queue Pair number
+        *     (u32) a1= command
+        */
+       CMD_QP_ENABLE = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 60),
+
+       /*
+        * Disable a Queue Pair in User space NIC
+        * in: (u32) a0=Queue Pair number
+        *     (u32) a1= command
+        */
+       CMD_QP_DISABLE = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 61),
+
+       /*
+        * Stats dump Queue Pair in User space NIC
+        * in: (u32) a0=Queue Pair number
+        *     (u64) a1=host buffer addr for status dump
+        *     (u32) a2=length of the buffer
+        */
+       CMD_QP_STATS_DUMP = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 62),
+
+       /*
+        * Clear stats for Queue Pair in User space NIC
+        * in: (u32) a0=Queue Pair number
+        */
+       CMD_QP_STATS_CLEAR = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 63),
+
+       /*
+        * Enable/Disable overlay offloads on the given vnic
+        * in: (u8) a0 = OVERLAY_FEATURE_NVGRE : NVGRE
+        *          a0 = OVERLAY_FEATURE_VXLAN : VxLAN
+        * in: (u8) a1 = OVERLAY_OFFLOAD_ENABLE : Enable
+        *          a1 = OVERLAY_OFFLOAD_DISABLE : Disable
+        */
+       CMD_OVERLAY_OFFLOAD_ENABLE_DISABLE =
+               _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 72),
+
+       /*
+        * Configuration of overlay offloads feature on a given vNIC
+        * in: (u8) a0 = DEVCMD_OVERLAY_NVGRE : NVGRE
+        *          a0 = DEVCMD_OVERLAY_VXLAN : VxLAN
+        * in: (u8) a1 = VXLAN_PORT_UPDATE : VxLAN
+        * in: (u16) a2 = unsigned short int port information
+        */
+       CMD_OVERLAY_OFFLOAD_CFG = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 73),
+};
+
+/* CMD_ENABLE2 flags */
+#define CMD_ENABLE2_STANDBY 0x0
+#define CMD_ENABLE2_ACTIVE  0x1
+
+/* flags for CMD_OPEN */
+#define CMD_OPENF_OPROM                0x1     /* open coming from option rom */
+
+/* flags for CMD_INIT */
+#define CMD_INITF_DEFAULT_MAC  0x1     /* init with default mac addr */
+
+/* flags for CMD_PACKET_FILTER */
+#define CMD_PFILTER_DIRECTED           0x01
+#define CMD_PFILTER_MULTICAST          0x02
+#define CMD_PFILTER_BROADCAST          0x04
+#define CMD_PFILTER_PROMISCUOUS                0x08
+#define CMD_PFILTER_ALL_MULTICAST      0x10
+
+/* Commands for CMD_QP_ENABLE/CM_QP_DISABLE */
+#define CMD_QP_RQWQ                     0x0
+
+/* rewrite modes for CMD_IG_VLAN_REWRITE_MODE */
+#define IG_VLAN_REWRITE_MODE_DEFAULT_TRUNK              0
+#define IG_VLAN_REWRITE_MODE_UNTAG_DEFAULT_VLAN         1
+#define IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN  2
+#define IG_VLAN_REWRITE_MODE_PASS_THRU                  3
+
+enum vnic_devcmd_status {
+       STAT_NONE = 0,
+       STAT_BUSY = 1 << 0,     /* cmd in progress */
+       STAT_ERROR = 1 << 1,    /* last cmd caused error (code in a0) */
+};
+
+enum vnic_devcmd_error {
+       ERR_SUCCESS = 0,
+       ERR_EINVAL = 1,
+       ERR_EFAULT = 2,
+       ERR_EPERM = 3,
+       ERR_EBUSY = 4,
+       ERR_ECMDUNKNOWN = 5,
+       ERR_EBADSTATE = 6,
+       ERR_ENOMEM = 7,
+       ERR_ETIMEDOUT = 8,
+       ERR_ELINKDOWN = 9,
+       ERR_EMAXRES = 10,
+       ERR_ENOTSUPPORTED = 11,
+       ERR_EINPROGRESS = 12,
+       ERR_MAX
+};
+
+/*
+ * note: hw_version and asic_rev refer to the same thing,
+ *       but have different formats. hw_version is
+ *       a 32-byte string (e.g. "A2") and asic_rev is
+ *       a 16-bit integer (e.g. 0xA2).
+ */
+struct vnic_devcmd_fw_info {
+       char fw_version[32];
+       char fw_build[32];
+       char hw_version[32];
+       char hw_serial_number[32];
+       u16 asic_type;
+       u16 asic_rev;
+};
+
+enum fwinfo_asic_type {
+       FWINFO_ASIC_TYPE_UNKNOWN,
+       FWINFO_ASIC_TYPE_PALO,
+       FWINFO_ASIC_TYPE_SERENO,
+};
+
+
+struct vnic_devcmd_notify {
+       u32 csum;               /* checksum over following words */
+
+       u32 link_state;         /* link up == 1 */
+       u32 port_speed;         /* effective port speed (rate limit) */
+       u32 mtu;                /* MTU */
+       u32 msglvl;             /* requested driver msg lvl */
+       u32 uif;                /* uplink interface */
+       u32 status;             /* status bits (see VNIC_STF_*) */
+       u32 error;              /* error code (see ERR_*) for first ERR */
+       u32 link_down_cnt;      /* running count of link down transitions */
+       u32 perbi_rebuild_cnt;  /* running count of perbi rebuilds */
+};
+#define VNIC_STF_FATAL_ERR     0x0001  /* fatal fw error */
+#define VNIC_STF_STD_PAUSE     0x0002  /* standard link-level pause on */
+#define VNIC_STF_PFC_PAUSE     0x0004  /* priority flow control pause on */
+/* all supported status flags */
+#define VNIC_STF_ALL           (VNIC_STF_FATAL_ERR |\
+                                VNIC_STF_STD_PAUSE |\
+                                VNIC_STF_PFC_PAUSE |\
+                                0)
+
+struct vnic_devcmd_provinfo {
+       u8 oui[3];
+       u8 type;
+       u8 data[0];
+};
+
+/*
+ * These are used in flags field of different filters to denote
+ * valid fields used.
+ */
+#define FILTER_FIELD_VALID(fld) (1 << (fld - 1))
+
+#define FILTER_FIELDS_USNIC (FILTER_FIELD_VALID(1) | \
+                            FILTER_FIELD_VALID(2) | \
+                            FILTER_FIELD_VALID(3) | \
+                            FILTER_FIELD_VALID(4))
+
+#define FILTER_FIELDS_IPV4_5TUPLE (FILTER_FIELD_VALID(1) | \
+                                  FILTER_FIELD_VALID(2) | \
+                                  FILTER_FIELD_VALID(3) | \
+                                  FILTER_FIELD_VALID(4) | \
+                                  FILTER_FIELD_VALID(5))
+
+#define FILTER_FIELDS_MAC_VLAN (FILTER_FIELD_VALID(1) | \
+                               FILTER_FIELD_VALID(2))
+
+#define FILTER_FIELD_USNIC_VLAN    FILTER_FIELD_VALID(1)
+#define FILTER_FIELD_USNIC_ETHTYPE FILTER_FIELD_VALID(2)
+#define FILTER_FIELD_USNIC_PROTO   FILTER_FIELD_VALID(3)
+#define FILTER_FIELD_USNIC_ID      FILTER_FIELD_VALID(4)
+
+struct filter_usnic_id {
+       u32 flags;
+       u16 vlan;
+       u16 ethtype;
+       u8 proto_version;
+       u32 usnic_id;
+} __attribute__((packed));
+
+#define FILTER_FIELD_5TUP_PROTO  FILTER_FIELD_VALID(1)
+#define FILTER_FIELD_5TUP_SRC_AD FILTER_FIELD_VALID(2)
+#define FILTER_FIELD_5TUP_DST_AD FILTER_FIELD_VALID(3)
+#define FILTER_FIELD_5TUP_SRC_PT FILTER_FIELD_VALID(4)
+#define FILTER_FIELD_5TUP_DST_PT FILTER_FIELD_VALID(5)
+
+/* Enums for the protocol field. */
+enum protocol_e {
+       PROTO_UDP = 0,
+       PROTO_TCP = 1,
+};
+
+struct filter_ipv4_5tuple {
+       u32 flags;
+       u32 protocol;
+       u32 src_addr;
+       u32 dst_addr;
+       u16 src_port;
+       u16 dst_port;
+} __attribute__((packed));
+
+#define FILTER_FIELD_VMQ_VLAN   FILTER_FIELD_VALID(1)
+#define FILTER_FIELD_VMQ_MAC    FILTER_FIELD_VALID(2)
+
+struct filter_mac_vlan {
+       u32 flags;
+       u16 vlan;
+       u8 mac_addr[6];
+} __attribute__((packed));
+
+/* Specifies the filter_action type. */
+enum {
+       FILTER_ACTION_RQ_STEERING = 0,
+       FILTER_ACTION_MAX
+};
+
+struct filter_action {
+       u32 type;
+       union {
+               u32 rq_idx;
+       } u;
+} __attribute__((packed));
+
+/* Specifies the filter type. */
+enum filter_type {
+       FILTER_USNIC_ID = 0,
+       FILTER_IPV4_5TUPLE = 1,
+       FILTER_MAC_VLAN = 2,
+       FILTER_MAX
+};
+
+struct filter {
+       u32 type;
+       union {
+               struct filter_usnic_id usnic;
+               struct filter_ipv4_5tuple ipv4;
+               struct filter_mac_vlan mac_vlan;
+       } u;
+} __attribute__((packed));
+
+enum {
+       CLSF_TLV_FILTER = 0,
+       CLSF_TLV_ACTION = 1,
+};
+
+#define FILTER_MAX_BUF_SIZE 100  /* Maximum size of buffer to CMD_ADD_FILTER */
+
+struct filter_tlv {
+       u_int32_t type;
+       u_int32_t length;
+       u_int32_t val[0];
+};
+
+enum {
+       CLSF_ADD = 0,
+       CLSF_DEL = 1,
+};
+
+/*
+ * Writing cmd register causes STAT_BUSY to get set in status register.
+ * When cmd completes, STAT_BUSY will be cleared.
+ *
+ * If cmd completed successfully STAT_ERROR will be clear
+ * and args registers contain cmd-specific results.
+ *
+ * If cmd error, STAT_ERROR will be set and args[0] contains error code.
+ *
+ * status register is read-only.  While STAT_BUSY is set,
+ * all other register contents are read-only.
+ */
+
+/* Make sizeof(vnic_devcmd) a power-of-2 for I/O BAR. */
+#define VNIC_DEVCMD_NARGS 15
+struct vnic_devcmd {
+       u32 status;                     /* RO */
+       u32 cmd;                        /* RW */
+       u64 args[VNIC_DEVCMD_NARGS];    /* RW cmd args (little-endian) */
+};
+
+/*
+ * Version 2 of the interface.
+ *
+ * Some things are carried over, notably the vnic_devcmd_cmd enum.
+ */
+
+/*
+ * Flags for vnic_devcmd2.flags
+ */
+
+#define DEVCMD2_FNORESULT       0x1     /* Don't copy result to host */
+
+#define VNIC_DEVCMD2_NARGS      VNIC_DEVCMD_NARGS
+struct vnic_devcmd2 {
+       u16 pad;
+       u16 flags;
+       u32 cmd;                /* same command #defines as original */
+       u64 args[VNIC_DEVCMD2_NARGS];
+};
+
+#define VNIC_DEVCMD2_NRESULTS   VNIC_DEVCMD_NARGS
+struct devcmd2_result {
+       u64 results[VNIC_DEVCMD2_NRESULTS];
+       u32 pad;
+       u16 completed_index;    /* into copy WQ */
+       u8  error;              /* same error codes as original */
+       u8  color;              /* 0 or 1 as with completion queues */
+};
+
+#define DEVCMD2_RING_SIZE   32
+#define DEVCMD2_DESC_SIZE   128
+
+#define DEVCMD2_RESULTS_SIZE_MAX   ((1 << 16) - 1)
+
+/* Overlay related definitions */
+
+/*
+ * This enum lists the flag associated with each of the overlay features
+ */
+typedef enum {
+       OVERLAY_FEATURE_NVGRE = 1,
+       OVERLAY_FEATURE_VXLAN,
+       OVERLAY_FEATURE_MAX,
+} overlay_feature_t;
+
+#define OVERLAY_OFFLOAD_ENABLE 0
+#define OVERLAY_OFFLOAD_DISABLE 1
+
+#define OVERLAY_CFG_VXLAN_PORT_UPDATE 0
+#endif /* _VNIC_DEVCMD_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_enet.h b/lib/librte_pmd_enic/vnic/vnic_enet.h
new file mode 100644 (file)
index 0000000..9d3cc07
--- /dev/null
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_enet.h 175806 2014-06-04 19:31:17Z rfaucett $"
+
+#ifndef _VNIC_ENIC_H_
+#define _VNIC_ENIC_H_
+
+/* Device-specific region: enet configuration */
+struct vnic_enet_config {
+       u32 flags;
+       u32 wq_desc_count;
+       u32 rq_desc_count;
+       u16 mtu;
+       u16 intr_timer_deprecated;
+       u8 intr_timer_type;
+       u8 intr_mode;
+       char devname[16];
+       u32 intr_timer_usec;
+       u16 loop_tag;
+       u16 vf_rq_count;
+       u16 num_arfs;
+       u64 mem_paddr;
+};
+
+#define VENETF_TSO             0x1     /* TSO enabled */
+#define VENETF_LRO             0x2     /* LRO enabled */
+#define VENETF_RXCSUM          0x4     /* RX csum enabled */
+#define VENETF_TXCSUM          0x8     /* TX csum enabled */
+#define VENETF_RSS             0x10    /* RSS enabled */
+#define VENETF_RSSHASH_IPV4    0x20    /* Hash on IPv4 fields */
+#define VENETF_RSSHASH_TCPIPV4 0x40    /* Hash on TCP + IPv4 fields */
+#define VENETF_RSSHASH_IPV6    0x80    /* Hash on IPv6 fields */
+#define VENETF_RSSHASH_TCPIPV6 0x100   /* Hash on TCP + IPv6 fields */
+#define VENETF_RSSHASH_IPV6_EX 0x200   /* Hash on IPv6 extended fields */
+#define VENETF_RSSHASH_TCPIPV6_EX 0x400        /* Hash on TCP + IPv6 ext. fields */
+#define VENETF_LOOP            0x800   /* Loopback enabled */
+#define VENETF_VMQ             0x4000  /* using VMQ flag for VMware NETQ */
+#define VENETF_VXLAN    0x10000 /* VxLAN offload */
+#define VENETF_NVGRE    0x20000 /* NVGRE offload */
+#define VENET_INTR_TYPE_MIN    0       /* Timer specs min interrupt spacing */
+#define VENET_INTR_TYPE_IDLE   1       /* Timer specs idle time before irq */
+
+#define VENET_INTR_MODE_ANY    0       /* Try MSI-X, then MSI, then INTx */
+#define VENET_INTR_MODE_MSI    1       /* Try MSI then INTx */
+#define VENET_INTR_MODE_INTX   2       /* Try INTx only */
+
+#endif /* _VNIC_ENIC_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_intr.c b/lib/librte_pmd_enic/vnic/vnic_intr.c
new file mode 100644 (file)
index 0000000..9be3744
--- /dev/null
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_intr.c 171146 2014-05-02 07:08:20Z ssujith $"
+
+#include "vnic_dev.h"
+#include "vnic_intr.h"
+
+void vnic_intr_free(struct vnic_intr *intr)
+{
+       intr->ctrl = NULL;
+}
+
+int vnic_intr_alloc(struct vnic_dev *vdev, struct vnic_intr *intr,
+       unsigned int index)
+{
+       intr->index = index;
+       intr->vdev = vdev;
+
+       intr->ctrl = vnic_dev_get_res(vdev, RES_TYPE_INTR_CTRL, index);
+       if (!intr->ctrl) {
+               pr_err("Failed to hook INTR[%d].ctrl resource\n", index);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+void vnic_intr_init(struct vnic_intr *intr, u32 coalescing_timer,
+       unsigned int coalescing_type, unsigned int mask_on_assertion)
+{
+       vnic_intr_coalescing_timer_set(intr, coalescing_timer);
+       iowrite32(coalescing_type, &intr->ctrl->coalescing_type);
+       iowrite32(mask_on_assertion, &intr->ctrl->mask_on_assertion);
+       iowrite32(0, &intr->ctrl->int_credits);
+}
+
+void vnic_intr_coalescing_timer_set(struct vnic_intr *intr,
+       u32 coalescing_timer)
+{
+       iowrite32(vnic_dev_intr_coal_timer_usec_to_hw(intr->vdev,
+               coalescing_timer), &intr->ctrl->coalescing_timer);
+}
+
+void vnic_intr_clean(struct vnic_intr *intr)
+{
+       iowrite32(0, &intr->ctrl->int_credits);
+}
+
+void vnic_intr_raise(struct vnic_intr *intr)
+{
+       vnic_dev_raise_intr(intr->vdev, (u16)intr->index);
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_intr.h b/lib/librte_pmd_enic/vnic/vnic_intr.h
new file mode 100644 (file)
index 0000000..ecb82bf
--- /dev/null
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_intr.h 171146 2014-05-02 07:08:20Z ssujith $"
+
+#ifndef _VNIC_INTR_H_
+#define _VNIC_INTR_H_
+
+
+#include "vnic_dev.h"
+
+#define VNIC_INTR_TIMER_TYPE_ABS       0
+#define VNIC_INTR_TIMER_TYPE_QUIET     1
+
+/* Interrupt control */
+struct vnic_intr_ctrl {
+       u32 coalescing_timer;           /* 0x00 */
+       u32 pad0;
+       u32 coalescing_value;           /* 0x08 */
+       u32 pad1;
+       u32 coalescing_type;            /* 0x10 */
+       u32 pad2;
+       u32 mask_on_assertion;          /* 0x18 */
+       u32 pad3;
+       u32 mask;                       /* 0x20 */
+       u32 pad4;
+       u32 int_credits;                /* 0x28 */
+       u32 pad5;
+       u32 int_credit_return;          /* 0x30 */
+       u32 pad6;
+};
+
+struct vnic_intr {
+       unsigned int index;
+       struct vnic_dev *vdev;
+       struct vnic_intr_ctrl __iomem *ctrl;            /* memory-mapped */
+};
+
+static inline void vnic_intr_unmask(struct vnic_intr *intr)
+{
+       iowrite32(0, &intr->ctrl->mask);
+}
+
+static inline void vnic_intr_mask(struct vnic_intr *intr)
+{
+       iowrite32(1, &intr->ctrl->mask);
+}
+
+static inline int vnic_intr_masked(struct vnic_intr *intr)
+{
+       return ioread32(&intr->ctrl->mask);
+}
+
+static inline void vnic_intr_return_credits(struct vnic_intr *intr,
+       unsigned int credits, int unmask, int reset_timer)
+{
+#define VNIC_INTR_UNMASK_SHIFT         16
+#define VNIC_INTR_RESET_TIMER_SHIFT    17
+
+       u32 int_credit_return = (credits & 0xffff) |
+               (unmask ? (1 << VNIC_INTR_UNMASK_SHIFT) : 0) |
+               (reset_timer ? (1 << VNIC_INTR_RESET_TIMER_SHIFT) : 0);
+
+       iowrite32(int_credit_return, &intr->ctrl->int_credit_return);
+}
+
+static inline unsigned int vnic_intr_credits(struct vnic_intr *intr)
+{
+       return ioread32(&intr->ctrl->int_credits);
+}
+
+static inline void vnic_intr_return_all_credits(struct vnic_intr *intr)
+{
+       unsigned int credits = vnic_intr_credits(intr);
+       int unmask = 1;
+       int reset_timer = 1;
+
+       vnic_intr_return_credits(intr, credits, unmask, reset_timer);
+}
+
+static inline u32 vnic_intr_legacy_pba(u32 __iomem *legacy_pba)
+{
+       /* read PBA without clearing */
+       return ioread32(legacy_pba);
+}
+
+void vnic_intr_free(struct vnic_intr *intr);
+int vnic_intr_alloc(struct vnic_dev *vdev, struct vnic_intr *intr,
+       unsigned int index);
+void vnic_intr_init(struct vnic_intr *intr, u32 coalescing_timer,
+       unsigned int coalescing_type, unsigned int mask_on_assertion);
+void vnic_intr_coalescing_timer_set(struct vnic_intr *intr,
+       u32 coalescing_timer);
+void vnic_intr_clean(struct vnic_intr *intr);
+
+#endif /* _VNIC_INTR_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_nic.h b/lib/librte_pmd_enic/vnic/vnic_nic.h
new file mode 100644 (file)
index 0000000..332cfb4
--- /dev/null
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_nic.h 59839 2010-09-27 20:36:31Z roprabhu $"
+
+#ifndef _VNIC_NIC_H_
+#define _VNIC_NIC_H_
+
+#define NIC_CFG_RSS_DEFAULT_CPU_MASK_FIELD     0xffUL
+#define NIC_CFG_RSS_DEFAULT_CPU_SHIFT          0
+#define NIC_CFG_RSS_HASH_TYPE                  (0xffUL << 8)
+#define NIC_CFG_RSS_HASH_TYPE_MASK_FIELD       0xffUL
+#define NIC_CFG_RSS_HASH_TYPE_SHIFT            8
+#define NIC_CFG_RSS_HASH_BITS                  (7UL << 16)
+#define NIC_CFG_RSS_HASH_BITS_MASK_FIELD       7UL
+#define NIC_CFG_RSS_HASH_BITS_SHIFT            16
+#define NIC_CFG_RSS_BASE_CPU                   (7UL << 19)
+#define NIC_CFG_RSS_BASE_CPU_MASK_FIELD                7UL
+#define NIC_CFG_RSS_BASE_CPU_SHIFT             19
+#define NIC_CFG_RSS_ENABLE                     (1UL << 22)
+#define NIC_CFG_RSS_ENABLE_MASK_FIELD          1UL
+#define NIC_CFG_RSS_ENABLE_SHIFT               22
+#define NIC_CFG_TSO_IPID_SPLIT_EN              (1UL << 23)
+#define NIC_CFG_TSO_IPID_SPLIT_EN_MASK_FIELD   1UL
+#define NIC_CFG_TSO_IPID_SPLIT_EN_SHIFT                23
+#define NIC_CFG_IG_VLAN_STRIP_EN               (1UL << 24)
+#define NIC_CFG_IG_VLAN_STRIP_EN_MASK_FIELD    1UL
+#define NIC_CFG_IG_VLAN_STRIP_EN_SHIFT         24
+
+#define NIC_CFG_RSS_HASH_TYPE_IPV4             (1 << 1)
+#define NIC_CFG_RSS_HASH_TYPE_TCP_IPV4         (1 << 2)
+#define NIC_CFG_RSS_HASH_TYPE_IPV6             (1 << 3)
+#define NIC_CFG_RSS_HASH_TYPE_TCP_IPV6         (1 << 4)
+#define NIC_CFG_RSS_HASH_TYPE_IPV6_EX          (1 << 5)
+#define NIC_CFG_RSS_HASH_TYPE_TCP_IPV6_EX      (1 << 6)
+
+static inline void vnic_set_nic_cfg(u32 *nic_cfg,
+       u8 rss_default_cpu, u8 rss_hash_type,
+       u8 rss_hash_bits, u8 rss_base_cpu,
+       u8 rss_enable, u8 tso_ipid_split_en,
+       u8 ig_vlan_strip_en)
+{
+       *nic_cfg = (rss_default_cpu & NIC_CFG_RSS_DEFAULT_CPU_MASK_FIELD) |
+               ((rss_hash_type & NIC_CFG_RSS_HASH_TYPE_MASK_FIELD)
+                       << NIC_CFG_RSS_HASH_TYPE_SHIFT) |
+               ((rss_hash_bits & NIC_CFG_RSS_HASH_BITS_MASK_FIELD)
+                       << NIC_CFG_RSS_HASH_BITS_SHIFT) |
+               ((rss_base_cpu & NIC_CFG_RSS_BASE_CPU_MASK_FIELD)
+                       << NIC_CFG_RSS_BASE_CPU_SHIFT) |
+               ((rss_enable & NIC_CFG_RSS_ENABLE_MASK_FIELD)
+                       << NIC_CFG_RSS_ENABLE_SHIFT) |
+               ((tso_ipid_split_en & NIC_CFG_TSO_IPID_SPLIT_EN_MASK_FIELD)
+                       << NIC_CFG_TSO_IPID_SPLIT_EN_SHIFT) |
+               ((ig_vlan_strip_en & NIC_CFG_IG_VLAN_STRIP_EN_MASK_FIELD)
+                       << NIC_CFG_IG_VLAN_STRIP_EN_SHIFT);
+}
+
+#endif /* _VNIC_NIC_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_resource.h b/lib/librte_pmd_enic/vnic/vnic_resource.h
new file mode 100644 (file)
index 0000000..2512712
--- /dev/null
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_resource.h 196958 2014-11-04 18:23:37Z xuywang $"
+
+#ifndef _VNIC_RESOURCE_H_
+#define _VNIC_RESOURCE_H_
+
+#define VNIC_RES_MAGIC         0x766E6963L     /* 'vnic' */
+#define VNIC_RES_VERSION       0x00000000L
+#define MGMTVNIC_MAGIC         0x544d474dL     /* 'MGMT' */
+#define MGMTVNIC_VERSION       0x00000000L
+
+/* The MAC address assigned to the CFG vNIC is fixed. */
+#define MGMTVNIC_MAC           { 0x02, 0x00, 0x54, 0x4d, 0x47, 0x4d }
+
+/* vNIC resource types */
+enum vnic_res_type {
+       RES_TYPE_EOL,                   /* End-of-list */
+       RES_TYPE_WQ,                    /* Work queues */
+       RES_TYPE_RQ,                    /* Receive queues */
+       RES_TYPE_CQ,                    /* Completion queues */
+       RES_TYPE_MEM,                   /* Window to dev memory */
+       RES_TYPE_NIC_CFG,               /* Enet NIC config registers */
+       RES_TYPE_RSS_KEY,               /* Enet RSS secret key */
+       RES_TYPE_RSS_CPU,               /* Enet RSS indirection table */
+       RES_TYPE_TX_STATS,              /* Netblock Tx statistic regs */
+       RES_TYPE_RX_STATS,              /* Netblock Rx statistic regs */
+       RES_TYPE_INTR_CTRL,             /* Interrupt ctrl table */
+       RES_TYPE_INTR_TABLE,            /* MSI/MSI-X Interrupt table */
+       RES_TYPE_INTR_PBA,              /* MSI/MSI-X PBA table */
+       RES_TYPE_INTR_PBA_LEGACY,       /* Legacy intr status */
+       RES_TYPE_DEBUG,                 /* Debug-only info */
+       RES_TYPE_DEV,                   /* Device-specific region */
+       RES_TYPE_DEVCMD,                /* Device command region */
+       RES_TYPE_PASS_THRU_PAGE,        /* Pass-thru page */
+       RES_TYPE_SUBVNIC,               /* subvnic resource type */
+       RES_TYPE_MQ_WQ,                 /* MQ Work queues */
+       RES_TYPE_MQ_RQ,                 /* MQ Receive queues */
+       RES_TYPE_MQ_CQ,                 /* MQ Completion queues */
+       RES_TYPE_DEPRECATED1,           /* Old version of devcmd 2 */
+       RES_TYPE_DEVCMD2,               /* Device control region */
+       RES_TYPE_MAX,                   /* Count of resource types */
+};
+
+struct vnic_resource_header {
+       u32 magic;
+       u32 version;
+};
+
+struct mgmt_barmap_hdr {
+       u32 magic;                      /* magic number */
+       u32 version;                    /* header format version */
+       u16 lif;                        /* loopback lif for mgmt frames */
+       u16 pci_slot;                   /* installed pci slot */
+       char serial[16];                /* card serial number */
+};
+
+struct vnic_resource {
+       u8 type;
+       u8 bar;
+       u8 pad[2];
+       u32 bar_offset;
+       u32 count;
+};
+
+#endif /* _VNIC_RESOURCE_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_rq.c b/lib/librte_pmd_enic/vnic/vnic_rq.c
new file mode 100644 (file)
index 0000000..3a4b65a
--- /dev/null
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_rq.c 171146 2014-05-02 07:08:20Z ssujith $"
+
+#include "vnic_dev.h"
+#include "vnic_rq.h"
+
+static int vnic_rq_alloc_bufs(struct vnic_rq *rq)
+{
+       struct vnic_rq_buf *buf;
+       unsigned int i, j, count = rq->ring.desc_count;
+       unsigned int blks = VNIC_RQ_BUF_BLKS_NEEDED(count);
+
+       for (i = 0; i < blks; i++) {
+               rq->bufs[i] = kzalloc(VNIC_RQ_BUF_BLK_SZ(count), GFP_ATOMIC);
+               if (!rq->bufs[i])
+                       return -ENOMEM;
+       }
+
+       for (i = 0; i < blks; i++) {
+               buf = rq->bufs[i];
+               for (j = 0; j < VNIC_RQ_BUF_BLK_ENTRIES(count); j++) {
+                       buf->index = i * VNIC_RQ_BUF_BLK_ENTRIES(count) + j;
+                       buf->desc = (u8 *)rq->ring.descs +
+                               rq->ring.desc_size * buf->index;
+                       if (buf->index + 1 == count) {
+                               buf->next = rq->bufs[0];
+                               break;
+                       } else if (j + 1 == VNIC_RQ_BUF_BLK_ENTRIES(count)) {
+                               buf->next = rq->bufs[i + 1];
+                       } else {
+                               buf->next = buf + 1;
+                               buf++;
+                       }
+               }
+       }
+
+       rq->to_use = rq->to_clean = rq->bufs[0];
+
+       return 0;
+}
+
+int vnic_rq_mem_size(struct vnic_rq *rq, unsigned int desc_count,
+       unsigned int desc_size)
+{
+       int mem_size = 0;
+
+       mem_size += vnic_dev_desc_ring_size(&rq->ring, desc_count, desc_size);
+
+       mem_size += VNIC_RQ_BUF_BLKS_NEEDED(rq->ring.desc_count) *
+               VNIC_RQ_BUF_BLK_SZ(rq->ring.desc_count);
+
+       return mem_size;
+}
+
+void vnic_rq_free(struct vnic_rq *rq)
+{
+       struct vnic_dev *vdev;
+       unsigned int i;
+
+       vdev = rq->vdev;
+
+       vnic_dev_free_desc_ring(vdev, &rq->ring);
+
+       for (i = 0; i < VNIC_RQ_BUF_BLKS_MAX; i++) {
+               if (rq->bufs[i]) {
+                       kfree(rq->bufs[i]);
+                       rq->bufs[i] = NULL;
+               }
+       }
+
+       rq->ctrl = NULL;
+}
+
+int vnic_rq_alloc(struct vnic_dev *vdev, struct vnic_rq *rq, unsigned int index,
+       unsigned int desc_count, unsigned int desc_size)
+{
+       int err;
+       char res_name[NAME_MAX];
+       static int instance;
+
+       rq->index = index;
+       rq->vdev = vdev;
+
+       rq->ctrl = vnic_dev_get_res(vdev, RES_TYPE_RQ, index);
+       if (!rq->ctrl) {
+               pr_err("Failed to hook RQ[%d] resource\n", index);
+               return -EINVAL;
+       }
+
+       vnic_rq_disable(rq);
+
+       snprintf(res_name, sizeof(res_name), "%d-rq-%d", instance++, index);
+       err = vnic_dev_alloc_desc_ring(vdev, &rq->ring, desc_count, desc_size,
+               rq->socket_id, res_name);
+       if (err)
+               return err;
+
+       err = vnic_rq_alloc_bufs(rq);
+       if (err) {
+               vnic_rq_free(rq);
+               return err;
+       }
+
+       return 0;
+}
+
+void vnic_rq_init_start(struct vnic_rq *rq, unsigned int cq_index,
+       unsigned int fetch_index, unsigned int posted_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset)
+{
+       u64 paddr;
+       unsigned int count = rq->ring.desc_count;
+
+       paddr = (u64)rq->ring.base_addr | VNIC_PADDR_TARGET;
+       writeq(paddr, &rq->ctrl->ring_base);
+       iowrite32(count, &rq->ctrl->ring_size);
+       iowrite32(cq_index, &rq->ctrl->cq_index);
+       iowrite32(error_interrupt_enable, &rq->ctrl->error_interrupt_enable);
+       iowrite32(error_interrupt_offset, &rq->ctrl->error_interrupt_offset);
+       iowrite32(0, &rq->ctrl->dropped_packet_count);
+       iowrite32(0, &rq->ctrl->error_status);
+       iowrite32(fetch_index, &rq->ctrl->fetch_index);
+       iowrite32(posted_index, &rq->ctrl->posted_index);
+
+       rq->to_use = rq->to_clean =
+               &rq->bufs[fetch_index / VNIC_RQ_BUF_BLK_ENTRIES(count)]
+                       [fetch_index % VNIC_RQ_BUF_BLK_ENTRIES(count)];
+}
+
+void vnic_rq_init(struct vnic_rq *rq, unsigned int cq_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset)
+{
+       u32 fetch_index = 0;
+       /* Use current fetch_index as the ring starting point */
+       fetch_index = ioread32(&rq->ctrl->fetch_index);
+
+       if (fetch_index == 0xFFFFFFFF) { /* check for hardware gone  */
+               /* Hardware surprise removal: reset fetch_index */
+               fetch_index = 0;
+       }
+
+       vnic_rq_init_start(rq, cq_index,
+               fetch_index, fetch_index,
+               error_interrupt_enable,
+               error_interrupt_offset);
+}
+
+void vnic_rq_error_out(struct vnic_rq *rq, unsigned int error)
+{
+       iowrite32(error, &rq->ctrl->error_status);
+}
+
+unsigned int vnic_rq_error_status(struct vnic_rq *rq)
+{
+       return ioread32(&rq->ctrl->error_status);
+}
+
+void vnic_rq_enable(struct vnic_rq *rq)
+{
+       iowrite32(1, &rq->ctrl->enable);
+}
+
+int vnic_rq_disable(struct vnic_rq *rq)
+{
+       unsigned int wait;
+
+       iowrite32(0, &rq->ctrl->enable);
+
+       /* Wait for HW to ACK disable request */
+       for (wait = 0; wait < 1000; wait++) {
+               if (!(ioread32(&rq->ctrl->running)))
+                       return 0;
+               udelay(10);
+       }
+
+       pr_err("Failed to disable RQ[%d]\n", rq->index);
+
+       return -ETIMEDOUT;
+}
+
+void vnic_rq_clean(struct vnic_rq *rq,
+       void (*buf_clean)(struct vnic_rq *rq, struct vnic_rq_buf *buf))
+{
+       struct vnic_rq_buf *buf;
+       u32 fetch_index;
+       unsigned int count = rq->ring.desc_count;
+
+       buf = rq->to_clean;
+
+       while (vnic_rq_desc_used(rq) > 0) {
+
+               (*buf_clean)(rq, buf);
+
+               buf = rq->to_clean = buf->next;
+               rq->ring.desc_avail++;
+       }
+
+       /* Use current fetch_index as the ring starting point */
+       fetch_index = ioread32(&rq->ctrl->fetch_index);
+
+       if (fetch_index == 0xFFFFFFFF) { /* check for hardware gone  */
+               /* Hardware surprise removal: reset fetch_index */
+               fetch_index = 0;
+       }
+       rq->to_use = rq->to_clean =
+               &rq->bufs[fetch_index / VNIC_RQ_BUF_BLK_ENTRIES(count)]
+                       [fetch_index % VNIC_RQ_BUF_BLK_ENTRIES(count)];
+       iowrite32(fetch_index, &rq->ctrl->posted_index);
+
+       vnic_dev_clear_desc_ring(&rq->ring);
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_rq.h b/lib/librte_pmd_enic/vnic/vnic_rq.h
new file mode 100644 (file)
index 0000000..54b6612
--- /dev/null
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_rq.h 180262 2014-07-02 07:57:43Z gvaradar $"
+
+#ifndef _VNIC_RQ_H_
+#define _VNIC_RQ_H_
+
+
+#include "vnic_dev.h"
+#include "vnic_cq.h"
+
+/* Receive queue control */
+struct vnic_rq_ctrl {
+       u64 ring_base;                  /* 0x00 */
+       u32 ring_size;                  /* 0x08 */
+       u32 pad0;
+       u32 posted_index;               /* 0x10 */
+       u32 pad1;
+       u32 cq_index;                   /* 0x18 */
+       u32 pad2;
+       u32 enable;                     /* 0x20 */
+       u32 pad3;
+       u32 running;                    /* 0x28 */
+       u32 pad4;
+       u32 fetch_index;                /* 0x30 */
+       u32 pad5;
+       u32 error_interrupt_enable;     /* 0x38 */
+       u32 pad6;
+       u32 error_interrupt_offset;     /* 0x40 */
+       u32 pad7;
+       u32 error_status;               /* 0x48 */
+       u32 pad8;
+       u32 dropped_packet_count;       /* 0x50 */
+       u32 pad9;
+       u32 dropped_packet_count_rc;    /* 0x58 */
+       u32 pad10;
+};
+
+/* Break the vnic_rq_buf allocations into blocks of 32/64 entries */
+#define VNIC_RQ_BUF_MIN_BLK_ENTRIES 32
+#define VNIC_RQ_BUF_DFLT_BLK_ENTRIES 64
+#define VNIC_RQ_BUF_BLK_ENTRIES(entries) \
+       ((unsigned int)((entries < VNIC_RQ_BUF_DFLT_BLK_ENTRIES) ? \
+       VNIC_RQ_BUF_MIN_BLK_ENTRIES : VNIC_RQ_BUF_DFLT_BLK_ENTRIES))
+#define VNIC_RQ_BUF_BLK_SZ(entries) \
+       (VNIC_RQ_BUF_BLK_ENTRIES(entries) * sizeof(struct vnic_rq_buf))
+#define VNIC_RQ_BUF_BLKS_NEEDED(entries) \
+       DIV_ROUND_UP(entries, VNIC_RQ_BUF_BLK_ENTRIES(entries))
+#define VNIC_RQ_BUF_BLKS_MAX VNIC_RQ_BUF_BLKS_NEEDED(4096)
+
+struct vnic_rq_buf {
+       struct vnic_rq_buf *next;
+       dma_addr_t dma_addr;
+       void *os_buf;
+       unsigned int os_buf_index;
+       unsigned int len;
+       unsigned int index;
+       void *desc;
+       uint64_t wr_id;
+};
+
+struct vnic_rq {
+       unsigned int index;
+       struct vnic_dev *vdev;
+       struct vnic_rq_ctrl __iomem *ctrl;              /* memory-mapped */
+       struct vnic_dev_ring ring;
+       struct vnic_rq_buf *bufs[VNIC_RQ_BUF_BLKS_MAX];
+       struct vnic_rq_buf *to_use;
+       struct vnic_rq_buf *to_clean;
+       void *os_buf_head;
+       unsigned int pkts_outstanding;
+
+       unsigned int socket_id;
+       struct rte_mempool *mp;
+};
+
+static inline unsigned int vnic_rq_desc_avail(struct vnic_rq *rq)
+{
+       /* how many does SW own? */
+       return rq->ring.desc_avail;
+}
+
+static inline unsigned int vnic_rq_desc_used(struct vnic_rq *rq)
+{
+       /* how many does HW own? */
+       return rq->ring.desc_count - rq->ring.desc_avail - 1;
+}
+
+static inline void *vnic_rq_next_desc(struct vnic_rq *rq)
+{
+       return rq->to_use->desc;
+}
+
+static inline unsigned int vnic_rq_next_index(struct vnic_rq *rq)
+{
+       return rq->to_use->index;
+}
+
+static inline void vnic_rq_post(struct vnic_rq *rq,
+       void *os_buf, unsigned int os_buf_index,
+       dma_addr_t dma_addr, unsigned int len,
+       uint64_t wrid)
+{
+       struct vnic_rq_buf *buf = rq->to_use;
+
+       buf->os_buf = os_buf;
+       buf->os_buf_index = os_buf_index;
+       buf->dma_addr = dma_addr;
+       buf->len = len;
+       buf->wr_id = wrid;
+
+       buf = buf->next;
+       rq->to_use = buf;
+       rq->ring.desc_avail--;
+
+       /* Move the posted_index every nth descriptor
+        */
+
+#ifndef VNIC_RQ_RETURN_RATE
+#define VNIC_RQ_RETURN_RATE            0xf     /* keep 2^n - 1 */
+#endif
+
+       if ((buf->index & VNIC_RQ_RETURN_RATE) == 0) {
+               /* Adding write memory barrier prevents compiler and/or CPU
+                * reordering, thus avoiding descriptor posting before
+                * descriptor is initialized. Otherwise, hardware can read
+                * stale descriptor fields.
+                */
+               wmb();
+               iowrite32(buf->index, &rq->ctrl->posted_index);
+       }
+}
+
+static inline void vnic_rq_post_commit(struct vnic_rq *rq,
+       void *os_buf, unsigned int os_buf_index,
+       dma_addr_t dma_addr, unsigned int len)
+{
+       struct vnic_rq_buf *buf = rq->to_use;
+
+       buf->os_buf = os_buf;
+       buf->os_buf_index = os_buf_index;
+       buf->dma_addr = dma_addr;
+       buf->len = len;
+
+       buf = buf->next;
+       rq->to_use = buf;
+       rq->ring.desc_avail--;
+
+       /* Move the posted_index every descriptor
+        */
+
+       /* Adding write memory barrier prevents compiler and/or CPU
+        * reordering, thus avoiding descriptor posting before
+        * descriptor is initialized. Otherwise, hardware can read
+        * stale descriptor fields.
+        */
+       wmb();
+       iowrite32(buf->index, &rq->ctrl->posted_index);
+}
+
+static inline void vnic_rq_return_descs(struct vnic_rq *rq, unsigned int count)
+{
+       rq->ring.desc_avail += count;
+}
+
+enum desc_return_options {
+       VNIC_RQ_RETURN_DESC,
+       VNIC_RQ_DEFER_RETURN_DESC,
+};
+
+static inline int vnic_rq_service(struct vnic_rq *rq,
+       struct cq_desc *cq_desc, u16 completed_index,
+       int desc_return, int (*buf_service)(struct vnic_rq *rq,
+       struct cq_desc *cq_desc, struct vnic_rq_buf *buf,
+       int skipped, void *opaque), void *opaque)
+{
+       struct vnic_rq_buf *buf;
+       int skipped;
+       int eop = 0;
+
+       buf = rq->to_clean;
+       while (1) {
+
+               skipped = (buf->index != completed_index);
+
+               if ((*buf_service)(rq, cq_desc, buf, skipped, opaque))
+                       eop++;
+
+               if (desc_return == VNIC_RQ_RETURN_DESC)
+                       rq->ring.desc_avail++;
+
+               rq->to_clean = buf->next;
+
+               if (!skipped)
+                       break;
+
+               buf = rq->to_clean;
+       }
+       return eop;
+}
+
+static inline int vnic_rq_fill(struct vnic_rq *rq,
+       int (*buf_fill)(struct vnic_rq *rq))
+{
+       int err;
+
+       while (vnic_rq_desc_avail(rq) > 0) {
+
+               err = (*buf_fill)(rq);
+               if (err)
+                       return err;
+       }
+
+       return 0;
+}
+
+static inline int vnic_rq_fill_count(struct vnic_rq *rq,
+       int (*buf_fill)(struct vnic_rq *rq), unsigned int count)
+{
+       int err;
+
+       while ((vnic_rq_desc_avail(rq) > 0) && (count--)) {
+
+               err = (*buf_fill)(rq);
+               if (err)
+                       return err;
+       }
+
+       return 0;
+}
+
+void vnic_rq_free(struct vnic_rq *rq);
+int vnic_rq_alloc(struct vnic_dev *vdev, struct vnic_rq *rq, unsigned int index,
+       unsigned int desc_count, unsigned int desc_size);
+void vnic_rq_init_start(struct vnic_rq *rq, unsigned int cq_index,
+       unsigned int fetch_index, unsigned int posted_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset);
+void vnic_rq_init(struct vnic_rq *rq, unsigned int cq_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset);
+void vnic_rq_error_out(struct vnic_rq *rq, unsigned int error);
+unsigned int vnic_rq_error_status(struct vnic_rq *rq);
+void vnic_rq_enable(struct vnic_rq *rq);
+int vnic_rq_disable(struct vnic_rq *rq);
+void vnic_rq_clean(struct vnic_rq *rq,
+       void (*buf_clean)(struct vnic_rq *rq, struct vnic_rq_buf *buf));
+int vnic_rq_mem_size(struct vnic_rq *rq, unsigned int desc_count,
+       unsigned int desc_size);
+
+#endif /* _VNIC_RQ_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_rss.c b/lib/librte_pmd_enic/vnic/vnic_rss.c
new file mode 100644 (file)
index 0000000..5ff76b1
--- /dev/null
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id$"
+
+#include "enic_compat.h"
+#include "vnic_rss.h"
+
+void vnic_set_rss_key(union vnic_rss_key *rss_key, u8 *key)
+{
+       u32 i;
+       u32 *p;
+       u16 *q;
+
+       for (i = 0; i < 4; ++i) {
+               p = (u32 *)(key + (10 * i));
+               iowrite32(*p++, &rss_key->key[i].b[0]);
+               iowrite32(*p++, &rss_key->key[i].b[4]);
+               q = (u16 *)p;
+               iowrite32(*q, &rss_key->key[i].b[8]);
+       }
+}
+
+void vnic_set_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu)
+{
+       u32 i;
+       u32 *p = (u32 *)cpu;
+
+       for (i = 0; i < 32; ++i)
+               iowrite32(*p++, &rss_cpu->cpu[i].b[0]);
+}
+
+void vnic_get_rss_key(union vnic_rss_key *rss_key, u8 *key)
+{
+       u32 i;
+       u32 *p;
+       u16 *q;
+
+       for (i = 0; i < 4; ++i) {
+               p = (u32 *)(key + (10 * i));
+               *p++ = ioread32(&rss_key->key[i].b[0]);
+               *p++ = ioread32(&rss_key->key[i].b[4]);
+               q = (u16 *)p;
+               *q = (u16)ioread32(&rss_key->key[i].b[8]);
+       }
+}
+
+void vnic_get_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu)
+{
+       u32 i;
+       u32 *p = (u32 *)cpu;
+
+       for (i = 0; i < 32; ++i)
+               *p++ = ioread32(&rss_cpu->cpu[i].b[0]);
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_rss.h b/lib/librte_pmd_enic/vnic/vnic_rss.h
new file mode 100644 (file)
index 0000000..45ed3d2
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ident "$Id: vnic_rss.h 64224 2010-11-09 19:43:13Z vkolluri $"
+
+#ifndef _VNIC_RSS_H_
+#define _VNIC_RSS_H_
+
+/* RSS key array */
+union vnic_rss_key {
+       struct {
+               u8 b[10];
+               u8 b_pad[6];
+       } key[4];
+       u64 raw[8];
+};
+
+/* RSS cpu array */
+union vnic_rss_cpu {
+       struct {
+               u8 b[4];
+               u8 b_pad[4];
+       } cpu[32];
+       u64 raw[32];
+};
+
+void vnic_set_rss_key(union vnic_rss_key *rss_key, u8 *key);
+void vnic_set_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu);
+void vnic_get_rss_key(union vnic_rss_key *rss_key, u8 *key);
+void vnic_get_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu);
+
+#endif /* _VNIC_RSS_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_stats.h b/lib/librte_pmd_enic/vnic/vnic_stats.h
new file mode 100644 (file)
index 0000000..ac5aa72
--- /dev/null
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_stats.h 84040 2011-08-09 23:38:43Z dwang2 $"
+
+#ifndef _VNIC_STATS_H_
+#define _VNIC_STATS_H_
+
+/* Tx statistics */
+struct vnic_tx_stats {
+       u64 tx_frames_ok;
+       u64 tx_unicast_frames_ok;
+       u64 tx_multicast_frames_ok;
+       u64 tx_broadcast_frames_ok;
+       u64 tx_bytes_ok;
+       u64 tx_unicast_bytes_ok;
+       u64 tx_multicast_bytes_ok;
+       u64 tx_broadcast_bytes_ok;
+       u64 tx_drops;
+       u64 tx_errors;
+       u64 tx_tso;
+       u64 rsvd[16];
+};
+
+/* Rx statistics */
+struct vnic_rx_stats {
+       u64 rx_frames_ok;
+       u64 rx_frames_total;
+       u64 rx_unicast_frames_ok;
+       u64 rx_multicast_frames_ok;
+       u64 rx_broadcast_frames_ok;
+       u64 rx_bytes_ok;
+       u64 rx_unicast_bytes_ok;
+       u64 rx_multicast_bytes_ok;
+       u64 rx_broadcast_bytes_ok;
+       u64 rx_drop;
+       u64 rx_no_bufs;
+       u64 rx_errors;
+       u64 rx_rss;
+       u64 rx_crc_errors;
+       u64 rx_frames_64;
+       u64 rx_frames_127;
+       u64 rx_frames_255;
+       u64 rx_frames_511;
+       u64 rx_frames_1023;
+       u64 rx_frames_1518;
+       u64 rx_frames_to_max;
+       u64 rsvd[16];
+};
+
+struct vnic_stats {
+       struct vnic_tx_stats tx;
+       struct vnic_rx_stats rx;
+};
+
+#endif /* _VNIC_STATS_H_ */
diff --git a/lib/librte_pmd_enic/vnic/vnic_wq.c b/lib/librte_pmd_enic/vnic/vnic_wq.c
new file mode 100644 (file)
index 0000000..e52cef0
--- /dev/null
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_wq.c 183023 2014-07-22 23:47:25Z xuywang $"
+
+#include "vnic_dev.h"
+#include "vnic_wq.h"
+
+static inline
+int vnic_wq_get_ctrl(struct vnic_dev *vdev, struct vnic_wq *wq,
+                               unsigned int index, enum vnic_res_type res_type)
+{
+       wq->ctrl = vnic_dev_get_res(vdev, res_type, index);
+       if (!wq->ctrl)
+               return -EINVAL;
+       return 0;
+}
+
+static inline
+int vnic_wq_alloc_ring(struct vnic_dev *vdev, struct vnic_wq *wq,
+                               unsigned int desc_count, unsigned int desc_size)
+{
+       char res_name[NAME_MAX];
+       static int instance;
+
+       snprintf(res_name, sizeof(res_name), "%d-wq-%d", instance++, wq->index);
+       return vnic_dev_alloc_desc_ring(vdev, &wq->ring, desc_count, desc_size,
+               wq->socket_id, res_name);
+}
+
+static int vnic_wq_alloc_bufs(struct vnic_wq *wq)
+{
+       struct vnic_wq_buf *buf;
+       unsigned int i, j, count = wq->ring.desc_count;
+       unsigned int blks = VNIC_WQ_BUF_BLKS_NEEDED(count);
+
+       for (i = 0; i < blks; i++) {
+               wq->bufs[i] = kzalloc(VNIC_WQ_BUF_BLK_SZ(count), GFP_ATOMIC);
+               if (!wq->bufs[i])
+                       return -ENOMEM;
+       }
+
+       for (i = 0; i < blks; i++) {
+               buf = wq->bufs[i];
+               for (j = 0; j < VNIC_WQ_BUF_BLK_ENTRIES(count); j++) {
+                       buf->index = i * VNIC_WQ_BUF_BLK_ENTRIES(count) + j;
+                       buf->desc = (u8 *)wq->ring.descs +
+                               wq->ring.desc_size * buf->index;
+                       if (buf->index + 1 == count) {
+                               buf->next = wq->bufs[0];
+                               break;
+                       } else if (j + 1 == VNIC_WQ_BUF_BLK_ENTRIES(count)) {
+                               buf->next = wq->bufs[i + 1];
+                       } else {
+                               buf->next = buf + 1;
+                               buf++;
+                       }
+               }
+       }
+
+       wq->to_use = wq->to_clean = wq->bufs[0];
+
+       return 0;
+}
+
+void vnic_wq_free(struct vnic_wq *wq)
+{
+       struct vnic_dev *vdev;
+       unsigned int i;
+
+       vdev = wq->vdev;
+
+       vnic_dev_free_desc_ring(vdev, &wq->ring);
+
+       for (i = 0; i < VNIC_WQ_BUF_BLKS_MAX; i++) {
+               if (wq->bufs[i]) {
+                       kfree(wq->bufs[i]);
+                       wq->bufs[i] = NULL;
+               }
+       }
+
+       wq->ctrl = NULL;
+}
+
+int vnic_wq_mem_size(struct vnic_wq *wq, unsigned int desc_count,
+       unsigned int desc_size)
+{
+       int mem_size = 0;
+
+       mem_size += vnic_dev_desc_ring_size(&wq->ring, desc_count, desc_size);
+
+       mem_size += VNIC_WQ_BUF_BLKS_NEEDED(wq->ring.desc_count) *
+               VNIC_WQ_BUF_BLK_SZ(wq->ring.desc_count);
+
+       return mem_size;
+}
+
+
+int vnic_wq_alloc(struct vnic_dev *vdev, struct vnic_wq *wq, unsigned int index,
+       unsigned int desc_count, unsigned int desc_size)
+{
+       int err;
+
+       wq->index = index;
+       wq->vdev = vdev;
+
+       err = vnic_wq_get_ctrl(vdev, wq, index, RES_TYPE_WQ);
+       if (err) {
+               pr_err("Failed to hook WQ[%d] resource, err %d\n", index, err);
+               return err;
+       }
+
+       vnic_wq_disable(wq);
+
+       err = vnic_wq_alloc_ring(vdev, wq, desc_count, desc_size);
+       if (err)
+               return err;
+
+       err = vnic_wq_alloc_bufs(wq);
+       if (err) {
+               vnic_wq_free(wq);
+               return err;
+       }
+
+       return 0;
+}
+
+void vnic_wq_init_start(struct vnic_wq *wq, unsigned int cq_index,
+       unsigned int fetch_index, unsigned int posted_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset)
+{
+       u64 paddr;
+       unsigned int count = wq->ring.desc_count;
+
+       paddr = (u64)wq->ring.base_addr | VNIC_PADDR_TARGET;
+       writeq(paddr, &wq->ctrl->ring_base);
+       iowrite32(count, &wq->ctrl->ring_size);
+       iowrite32(fetch_index, &wq->ctrl->fetch_index);
+       iowrite32(posted_index, &wq->ctrl->posted_index);
+       iowrite32(cq_index, &wq->ctrl->cq_index);
+       iowrite32(error_interrupt_enable, &wq->ctrl->error_interrupt_enable);
+       iowrite32(error_interrupt_offset, &wq->ctrl->error_interrupt_offset);
+       iowrite32(0, &wq->ctrl->error_status);
+
+       wq->to_use = wq->to_clean =
+               &wq->bufs[fetch_index / VNIC_WQ_BUF_BLK_ENTRIES(count)]
+                       [fetch_index % VNIC_WQ_BUF_BLK_ENTRIES(count)];
+}
+
+void vnic_wq_init(struct vnic_wq *wq, unsigned int cq_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset)
+{
+       vnic_wq_init_start(wq, cq_index, 0, 0,
+               error_interrupt_enable,
+               error_interrupt_offset);
+}
+
+void vnic_wq_error_out(struct vnic_wq *wq, unsigned int error)
+{
+       iowrite32(error, &wq->ctrl->error_status);
+}
+
+unsigned int vnic_wq_error_status(struct vnic_wq *wq)
+{
+       return ioread32(&wq->ctrl->error_status);
+}
+
+void vnic_wq_enable(struct vnic_wq *wq)
+{
+       iowrite32(1, &wq->ctrl->enable);
+}
+
+int vnic_wq_disable(struct vnic_wq *wq)
+{
+       unsigned int wait;
+
+       iowrite32(0, &wq->ctrl->enable);
+
+       /* Wait for HW to ACK disable request */
+       for (wait = 0; wait < 1000; wait++) {
+               if (!(ioread32(&wq->ctrl->running)))
+                       return 0;
+               udelay(10);
+       }
+
+       pr_err("Failed to disable WQ[%d]\n", wq->index);
+
+       return -ETIMEDOUT;
+}
+
+void vnic_wq_clean(struct vnic_wq *wq,
+       void (*buf_clean)(struct vnic_wq *wq, struct vnic_wq_buf *buf))
+{
+       struct vnic_wq_buf *buf;
+
+       buf = wq->to_clean;
+
+       while (vnic_wq_desc_used(wq) > 0) {
+
+               (*buf_clean)(wq, buf);
+
+               buf = wq->to_clean = buf->next;
+               wq->ring.desc_avail++;
+       }
+
+       wq->to_use = wq->to_clean = wq->bufs[0];
+
+       iowrite32(0, &wq->ctrl->fetch_index);
+       iowrite32(0, &wq->ctrl->posted_index);
+       iowrite32(0, &wq->ctrl->error_status);
+
+       vnic_dev_clear_desc_ring(&wq->ring);
+}
diff --git a/lib/librte_pmd_enic/vnic/vnic_wq.h b/lib/librte_pmd_enic/vnic/vnic_wq.h
new file mode 100644 (file)
index 0000000..f8219ad
--- /dev/null
@@ -0,0 +1,283 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: vnic_wq.h 183023 2014-07-22 23:47:25Z xuywang $"
+
+#ifndef _VNIC_WQ_H_
+#define _VNIC_WQ_H_
+
+
+#include "vnic_dev.h"
+#include "vnic_cq.h"
+
+/* Work queue control */
+struct vnic_wq_ctrl {
+       u64 ring_base;                  /* 0x00 */
+       u32 ring_size;                  /* 0x08 */
+       u32 pad0;
+       u32 posted_index;               /* 0x10 */
+       u32 pad1;
+       u32 cq_index;                   /* 0x18 */
+       u32 pad2;
+       u32 enable;                     /* 0x20 */
+       u32 pad3;
+       u32 running;                    /* 0x28 */
+       u32 pad4;
+       u32 fetch_index;                /* 0x30 */
+       u32 pad5;
+       u32 dca_value;                  /* 0x38 */
+       u32 pad6;
+       u32 error_interrupt_enable;     /* 0x40 */
+       u32 pad7;
+       u32 error_interrupt_offset;     /* 0x48 */
+       u32 pad8;
+       u32 error_status;               /* 0x50 */
+       u32 pad9;
+};
+
+struct vnic_wq_buf {
+       struct vnic_wq_buf *next;
+       dma_addr_t dma_addr;
+       void *os_buf;
+       unsigned int len;
+       unsigned int index;
+       int sop;
+       void *desc;
+       uint64_t wr_id; /* Cookie */
+       uint8_t cq_entry; /* Gets completion event from hw */
+       uint8_t desc_skip_cnt; /* Num descs to occupy */
+       uint8_t compressed_send; /* Both hdr and payload in one desc */
+};
+
+/* Break the vnic_wq_buf allocations into blocks of 32/64 entries */
+#define VNIC_WQ_BUF_MIN_BLK_ENTRIES 32
+#define VNIC_WQ_BUF_DFLT_BLK_ENTRIES 64
+#define VNIC_WQ_BUF_BLK_ENTRIES(entries) \
+       ((unsigned int)((entries < VNIC_WQ_BUF_DFLT_BLK_ENTRIES) ? \
+       VNIC_WQ_BUF_MIN_BLK_ENTRIES : VNIC_WQ_BUF_DFLT_BLK_ENTRIES))
+#define VNIC_WQ_BUF_BLK_SZ(entries) \
+       (VNIC_WQ_BUF_BLK_ENTRIES(entries) * sizeof(struct vnic_wq_buf))
+#define VNIC_WQ_BUF_BLKS_NEEDED(entries) \
+       DIV_ROUND_UP(entries, VNIC_WQ_BUF_BLK_ENTRIES(entries))
+#define VNIC_WQ_BUF_BLKS_MAX VNIC_WQ_BUF_BLKS_NEEDED(4096)
+
+struct vnic_wq {
+       unsigned int index;
+       struct vnic_dev *vdev;
+       struct vnic_wq_ctrl __iomem *ctrl;              /* memory-mapped */
+       struct vnic_dev_ring ring;
+       struct vnic_wq_buf *bufs[VNIC_WQ_BUF_BLKS_MAX];
+       struct vnic_wq_buf *to_use;
+       struct vnic_wq_buf *to_clean;
+       unsigned int pkts_outstanding;
+       unsigned int socket_id;
+};
+
+static inline unsigned int vnic_wq_desc_avail(struct vnic_wq *wq)
+{
+       /* how many does SW own? */
+       return wq->ring.desc_avail;
+}
+
+static inline unsigned int vnic_wq_desc_used(struct vnic_wq *wq)
+{
+       /* how many does HW own? */
+       return wq->ring.desc_count - wq->ring.desc_avail - 1;
+}
+
+static inline void *vnic_wq_next_desc(struct vnic_wq *wq)
+{
+       return wq->to_use->desc;
+}
+
+#define PI_LOG2_CACHE_LINE_SIZE        5
+#define PI_INDEX_BITS            12
+#define PI_INDEX_MASK ((1U << PI_INDEX_BITS) - 1)
+#define PI_PREFETCH_LEN_MASK ((1U << PI_LOG2_CACHE_LINE_SIZE) - 1)
+#define PI_PREFETCH_LEN_OFF 16
+#define PI_PREFETCH_ADDR_BITS 43
+#define PI_PREFETCH_ADDR_MASK ((1ULL << PI_PREFETCH_ADDR_BITS) - 1)
+#define PI_PREFETCH_ADDR_OFF 21
+
+/** How many cache lines are touched by buffer (addr, len). */
+static inline unsigned int num_cache_lines_touched(dma_addr_t addr,
+                                                       unsigned int len)
+{
+       const unsigned long mask = PI_PREFETCH_LEN_MASK;
+       const unsigned long laddr = (unsigned long)addr;
+       unsigned long lines, equiv_len;
+       /* A. If addr is aligned, our solution is just to round up len to the
+       next boundary.
+
+       e.g. addr = 0, len = 48
+       +--------------------+
+       |XXXXXXXXXXXXXXXXXXXX|    32-byte cacheline a
+       +--------------------+
+       |XXXXXXXXXX          |    cacheline b
+       +--------------------+
+
+       B. If addr is not aligned, however, we may use an extra
+       cacheline.  e.g. addr = 12, len = 22
+
+       +--------------------+
+       |       XXXXXXXXXXXXX|
+       +--------------------+
+       |XX                  |
+       +--------------------+
+
+       Our solution is to make the problem equivalent to case A
+       above by adding the empty space in the first cacheline to the length:
+       unsigned long len;
+
+       +--------------------+
+       |eeeeeeeXXXXXXXXXXXXX|    "e" is empty space, which we add to len
+       +--------------------+
+       |XX                  |
+       +--------------------+
+
+       */
+       equiv_len = len + (laddr & mask);
+
+       /* Now we can just round up this len to the next 32-byte boundary. */
+       lines = (equiv_len + mask) & (~mask);
+
+       /* Scale bytes -> cachelines. */
+       return lines >> PI_LOG2_CACHE_LINE_SIZE;
+}
+
+static inline u64 vnic_cached_posted_index(dma_addr_t addr, unsigned int len,
+                                               unsigned int index)
+{
+       unsigned int num_cache_lines = num_cache_lines_touched(addr, len);
+       /* Wish we could avoid a branch here.  We could have separate
+        * vnic_wq_post() and vinc_wq_post_inline(), the latter
+        * only supporting < 1k (2^5 * 2^5) sends, I suppose.  This would
+        * eliminate the if (eop) branch as well.
+        */
+       if (num_cache_lines > PI_PREFETCH_LEN_MASK)
+               num_cache_lines = 0;
+       return (index & PI_INDEX_MASK) |
+       ((num_cache_lines & PI_PREFETCH_LEN_MASK) << PI_PREFETCH_LEN_OFF) |
+               (((addr >> PI_LOG2_CACHE_LINE_SIZE) &
+       PI_PREFETCH_ADDR_MASK) << PI_PREFETCH_ADDR_OFF);
+}
+
+static inline void vnic_wq_post(struct vnic_wq *wq,
+       void *os_buf, dma_addr_t dma_addr,
+       unsigned int len, int sop, int eop,
+       uint8_t desc_skip_cnt, uint8_t cq_entry,
+       uint8_t compressed_send, uint64_t wrid)
+{
+       struct vnic_wq_buf *buf = wq->to_use;
+
+       buf->sop = sop;
+       buf->cq_entry = cq_entry;
+       buf->compressed_send = compressed_send;
+       buf->desc_skip_cnt = desc_skip_cnt;
+       buf->os_buf = os_buf;
+       buf->dma_addr = dma_addr;
+       buf->len = len;
+       buf->wr_id = wrid;
+
+       buf = buf->next;
+       if (eop) {
+#ifdef DO_PREFETCH
+               uint64_t wr = vnic_cached_posted_index(dma_addr, len,
+                                                       buf->index);
+#endif
+               /* Adding write memory barrier prevents compiler and/or CPU
+                * reordering, thus avoiding descriptor posting before
+                * descriptor is initialized. Otherwise, hardware can read
+                * stale descriptor fields.
+                */
+               wmb();
+#ifdef DO_PREFETCH
+               /* Intel chipsets seem to limit the rate of PIOs that we can
+                * push on the bus.  Thus, it is very important to do a single
+                * 64 bit write here.  With two 32-bit writes, my maximum
+                * pkt/sec rate was cut almost in half. -AJF
+                */
+               iowrite64((uint64_t)wr, &wq->ctrl->posted_index);
+#else
+               iowrite32(buf->index, &wq->ctrl->posted_index);
+#endif
+       }
+       wq->to_use = buf;
+
+       wq->ring.desc_avail -= desc_skip_cnt;
+}
+
+static inline void vnic_wq_service(struct vnic_wq *wq,
+       struct cq_desc *cq_desc, u16 completed_index,
+       void (*buf_service)(struct vnic_wq *wq,
+       struct cq_desc *cq_desc, struct vnic_wq_buf *buf, void *opaque),
+       void *opaque)
+{
+       struct vnic_wq_buf *buf;
+
+       buf = wq->to_clean;
+       while (1) {
+
+               (*buf_service)(wq, cq_desc, buf, opaque);
+
+               wq->ring.desc_avail++;
+
+               wq->to_clean = buf->next;
+
+               if (buf->index == completed_index)
+                       break;
+
+               buf = wq->to_clean;
+       }
+}
+
+void vnic_wq_free(struct vnic_wq *wq);
+int vnic_wq_alloc(struct vnic_dev *vdev, struct vnic_wq *wq, unsigned int index,
+       unsigned int desc_count, unsigned int desc_size);
+void vnic_wq_init_start(struct vnic_wq *wq, unsigned int cq_index,
+       unsigned int fetch_index, unsigned int posted_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset);
+void vnic_wq_init(struct vnic_wq *wq, unsigned int cq_index,
+       unsigned int error_interrupt_enable,
+       unsigned int error_interrupt_offset);
+void vnic_wq_error_out(struct vnic_wq *wq, unsigned int error);
+unsigned int vnic_wq_error_status(struct vnic_wq *wq);
+void vnic_wq_enable(struct vnic_wq *wq);
+int vnic_wq_disable(struct vnic_wq *wq);
+void vnic_wq_clean(struct vnic_wq *wq,
+       void (*buf_clean)(struct vnic_wq *wq, struct vnic_wq_buf *buf));
+int vnic_wq_mem_size(struct vnic_wq *wq, unsigned int desc_count,
+       unsigned int desc_size);
+
+#endif /* _VNIC_WQ_H_ */
diff --git a/lib/librte_pmd_enic/vnic/wq_enet_desc.h b/lib/librte_pmd_enic/vnic/wq_enet_desc.h
new file mode 100644 (file)
index 0000000..ff2b768
--- /dev/null
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2008-2010 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2014, Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ident "$Id: wq_enet_desc.h 59839 2010-09-27 20:36:31Z roprabhu $"
+
+#ifndef _WQ_ENET_DESC_H_
+#define _WQ_ENET_DESC_H_
+
+/* Ethernet work queue descriptor: 16B */
+struct wq_enet_desc {
+       __le64 address;
+       __le16 length;
+       __le16 mss_loopback;
+       __le16 header_length_flags;
+       __le16 vlan_tag;
+};
+
+#define WQ_ENET_ADDR_BITS              64
+#define WQ_ENET_LEN_BITS               14
+#define WQ_ENET_LEN_MASK               ((1 << WQ_ENET_LEN_BITS) - 1)
+#define WQ_ENET_MSS_BITS               14
+#define WQ_ENET_MSS_MASK               ((1 << WQ_ENET_MSS_BITS) - 1)
+#define WQ_ENET_MSS_SHIFT              2
+#define WQ_ENET_LOOPBACK_SHIFT         1
+#define WQ_ENET_HDRLEN_BITS            10
+#define WQ_ENET_HDRLEN_MASK            ((1 << WQ_ENET_HDRLEN_BITS) - 1)
+#define WQ_ENET_FLAGS_OM_BITS          2
+#define WQ_ENET_FLAGS_OM_MASK          ((1 << WQ_ENET_FLAGS_OM_BITS) - 1)
+#define WQ_ENET_FLAGS_EOP_SHIFT                12
+#define WQ_ENET_FLAGS_CQ_ENTRY_SHIFT   13
+#define WQ_ENET_FLAGS_FCOE_ENCAP_SHIFT 14
+#define WQ_ENET_FLAGS_VLAN_TAG_INSERT_SHIFT    15
+
+#define WQ_ENET_OFFLOAD_MODE_CSUM      0
+#define WQ_ENET_OFFLOAD_MODE_RESERVED  1
+#define WQ_ENET_OFFLOAD_MODE_CSUM_L4   2
+#define WQ_ENET_OFFLOAD_MODE_TSO       3
+
+static inline void wq_enet_desc_enc(struct wq_enet_desc *desc,
+       u64 address, u16 length, u16 mss, u16 header_length,
+       u8 offload_mode, u8 eop, u8 cq_entry, u8 fcoe_encap,
+       u8 vlan_tag_insert, u16 vlan_tag, u8 loopback)
+{
+       desc->address = cpu_to_le64(address);
+       desc->length = cpu_to_le16(length & WQ_ENET_LEN_MASK);
+       desc->mss_loopback = cpu_to_le16((mss & WQ_ENET_MSS_MASK) <<
+               WQ_ENET_MSS_SHIFT | (loopback & 1) << WQ_ENET_LOOPBACK_SHIFT);
+       desc->header_length_flags = cpu_to_le16(
+               (header_length & WQ_ENET_HDRLEN_MASK) |
+               (offload_mode & WQ_ENET_FLAGS_OM_MASK) << WQ_ENET_HDRLEN_BITS |
+               (eop & 1) << WQ_ENET_FLAGS_EOP_SHIFT |
+               (cq_entry & 1) << WQ_ENET_FLAGS_CQ_ENTRY_SHIFT |
+               (fcoe_encap & 1) << WQ_ENET_FLAGS_FCOE_ENCAP_SHIFT |
+               (vlan_tag_insert & 1) << WQ_ENET_FLAGS_VLAN_TAG_INSERT_SHIFT);
+       desc->vlan_tag = cpu_to_le16(vlan_tag);
+}
+
+static inline void wq_enet_desc_dec(struct wq_enet_desc *desc,
+       u64 *address, u16 *length, u16 *mss, u16 *header_length,
+       u8 *offload_mode, u8 *eop, u8 *cq_entry, u8 *fcoe_encap,
+       u8 *vlan_tag_insert, u16 *vlan_tag, u8 *loopback)
+{
+       *address = le64_to_cpu(desc->address);
+       *length = le16_to_cpu(desc->length) & WQ_ENET_LEN_MASK;
+       *mss = (le16_to_cpu(desc->mss_loopback) >> WQ_ENET_MSS_SHIFT) &
+               WQ_ENET_MSS_MASK;
+       *loopback = (u8)((le16_to_cpu(desc->mss_loopback) >>
+               WQ_ENET_LOOPBACK_SHIFT) & 1);
+       *header_length = le16_to_cpu(desc->header_length_flags) &
+               WQ_ENET_HDRLEN_MASK;
+       *offload_mode = (u8)((le16_to_cpu(desc->header_length_flags) >>
+               WQ_ENET_HDRLEN_BITS) & WQ_ENET_FLAGS_OM_MASK);
+       *eop = (u8)((le16_to_cpu(desc->header_length_flags) >>
+               WQ_ENET_FLAGS_EOP_SHIFT) & 1);
+       *cq_entry = (u8)((le16_to_cpu(desc->header_length_flags) >>
+               WQ_ENET_FLAGS_CQ_ENTRY_SHIFT) & 1);
+       *fcoe_encap = (u8)((le16_to_cpu(desc->header_length_flags) >>
+               WQ_ENET_FLAGS_FCOE_ENCAP_SHIFT) & 1);
+       *vlan_tag_insert = (u8)((le16_to_cpu(desc->header_length_flags) >>
+               WQ_ENET_FLAGS_VLAN_TAG_INSERT_SHIFT) & 1);
+       *vlan_tag = le16_to_cpu(desc->vlan_tag);
+}
+
+#endif /* _WQ_ENET_DESC_H_ */