net/mrvl: add net PMD skeleton
authorTomasz Duszynski <tdu@semihalf.com>
Mon, 9 Oct 2017 15:00:30 +0000 (17:00 +0200)
committerFerruh Yigit <ferruh.yigit@intel.com>
Thu, 12 Oct 2017 00:36:58 +0000 (01:36 +0100)
Add mrvl net pmd driver skeleton providing base for the further
development. Besides the basic functionality QoS configuration is
introduced as well.

Signed-off-by: Jacek Siuda <jck@semihalf.com>
Signed-off-by: Tomasz Duszynski <tdu@semihalf.com>
MAINTAINERS
config/common_base
doc/guides/rel_notes/release_17_11.rst
drivers/net/Makefile
drivers/net/mrvl/Makefile [new file with mode: 0644]
drivers/net/mrvl/mrvl_ethdev.c [new file with mode: 0644]
drivers/net/mrvl/mrvl_ethdev.h [new file with mode: 0644]
drivers/net/mrvl/mrvl_qos.c [new file with mode: 0644]
drivers/net/mrvl/mrvl_qos.h [new file with mode: 0644]
drivers/net/mrvl/rte_pmd_mrvl_version.map [new file with mode: 0644]
mk/rte.app.mk

index 9590025..0e23774 100644 (file)
@@ -401,6 +401,14 @@ F: drivers/net/mlx5/
 F: doc/guides/nics/mlx5.rst
 F: doc/guides/nics/features/mlx5.ini
 
+Marvell mrvl
+M: Jacek Siuda <jck@semihalf.com>
+M: Tomasz Duszynski <tdu@semihalf.com>
+M: Dmitri Epshtein <dima@marvell.com>
+M: Natalie Samsonov <nsamsono@marvell.com>
+M: Jianbo Liu <jianbo.liu@arm.com>
+F: drivers/net/mrvl/
+
 Netcope szedata2
 M: Matej Vido <vido@cesnet.cz>
 F: drivers/net/szedata2/
index 1813c9d..4648943 100644 (file)
@@ -260,6 +260,13 @@ CONFIG_RTE_LIBRTE_ENIC_DEBUG_FLOW=n
 CONFIG_RTE_LIBRTE_NFP_PMD=n
 CONFIG_RTE_LIBRTE_NFP_DEBUG=n
 
+#
+# Compile Marvell PMD driver
+#
+CONFIG_RTE_LIBRTE_MRVL_PMD=n
+CONFIG_RTE_LIBRTE_MRVL_DEBUG=n
+CONFIG_RTE_MRVL_MUSDK_DMA_MEMSIZE=41943040
+
 #
 # Compile burst-oriented Broadcom BNXT PMD driver
 #
index b29a9ca..892c6bd 100644 (file)
@@ -47,6 +47,12 @@ New Features
   256 ports in dpdk. All ethdev APIs which have port_id as parameter are changed
   in the meantime.
 
+* **Added a new driver for Marvell Armada 7k/8k devices.**
+
+  Added the new mrvl net driver for Marvell Armada 7k/8k devices. See the
+  "Network Interface Controller Drivers" document for more details on this new
+  driver.
+
 * **nfp: Added PF support.**
 
   Previously Netronome's NFP PMD had just support for VFs. PF support is
index 1daa87f..aa5edf8 100644 (file)
@@ -75,6 +75,8 @@ DIRS-$(CONFIG_RTE_LIBRTE_MLX4_PMD) += mlx4
 DEPDIRS-mlx4 = $(core-libs)
 DIRS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5
 DEPDIRS-mlx5 = $(core-libs)
+DIRS-$(CONFIG_RTE_LIBRTE_MRVL_PMD) += mrvl
+DEPDIRS-mrvl = $(core-libs) librte_cfgfile
 DIRS-$(CONFIG_RTE_LIBRTE_NFP_PMD) += nfp
 DEPDIRS-nfp = $(core-libs)
 DIRS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += bnxt
@@ -112,4 +114,10 @@ DIRS-$(CONFIG_RTE_LIBRTE_PMD_VHOST) += vhost
 endif # $(CONFIG_RTE_LIBRTE_VHOST)
 DEPDIRS-vhost = $(core-libs) librte_vhost
 
+ifeq ($(CONFIG_RTE_LIBRTE_MRVL_PMD),y)
+ifeq ($(CONFIG_RTE_LIBRTE_CFGFILE),n)
+$(error "RTE_LIBRTE_CFGFILE must be enabled in configuration!")
+endif
+endif
+
 include $(RTE_SDK)/mk/rte.subdir.mk
diff --git a/drivers/net/mrvl/Makefile b/drivers/net/mrvl/Makefile
new file mode 100644 (file)
index 0000000..26fce18
--- /dev/null
@@ -0,0 +1,63 @@
+#   BSD LICENSE
+#
+#   Copyright(c) 2017 Semihalf. All rights reserved.
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * 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.
+#     * Neither the name of Semihalf nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+#   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
+#   OWNER 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.
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+ifneq ($(MAKECMDGOALS),clean)
+ifneq ($(MAKECMDGOALS),config)
+ifeq ($(LIBMUSDK_PATH),)
+$(error "Please define LIBMUSDK_PATH environment variable")
+endif
+endif
+endif
+
+# library name
+LIB = librte_pmd_mrvl.a
+
+# library version
+LIBABIVER := 1
+
+# versioning export map
+EXPORT_MAP := rte_pmd_mrvl_version.map
+
+# external library dependencies
+CFLAGS += -I$(LIBMUSDK_PATH)/include
+CFLAGS += -DMVCONF_ARCH_DMA_ADDR_T_64BIT
+CFLAGS += -DCONF_PP2_BPOOL_COOKIE_SIZE=32
+CFLAGS += $(WERROR_FLAGS)
+CFLAGS += -O3
+LDLIBS += -L$(LIBMUSDK_PATH)/lib
+LDLIBS += -lmusdk
+
+# library source files
+SRCS-$(CONFIG_RTE_LIBRTE_MRVL_PMD) += mrvl_ethdev.c
+SRCS-$(CONFIG_RTE_LIBRTE_MRVL_PMD) += mrvl_qos.c
+
+include $(RTE_SDK)/mk/rte.lib.mk
diff --git a/drivers/net/mrvl/mrvl_ethdev.c b/drivers/net/mrvl/mrvl_ethdev.c
new file mode 100644 (file)
index 0000000..1e730c6
--- /dev/null
@@ -0,0 +1,1112 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2017 Semihalf. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Semihalf nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   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
+ *   OWNER 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.
+ */
+
+#include <rte_ethdev.h>
+#include <rte_kvargs.h>
+#include <rte_log.h>
+#include <rte_malloc.h>
+#include <rte_vdev.h>
+
+/* Unluckily, container_of is defined by both DPDK and MUSDK,
+ * we'll declare only one version.
+ *
+ * Note that it is not used in this PMD anyway.
+ */
+#ifdef container_of
+#undef container_of
+#endif
+
+#include <drivers/mv_pp2.h>
+#include <drivers/mv_pp2_bpool.h>
+#include <drivers/mv_pp2_hif.h>
+
+#include <fcntl.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "mrvl_ethdev.h"
+#include "mrvl_qos.h"
+
+/* bitmask with reserved hifs */
+#define MRVL_MUSDK_HIFS_RESERVED 0x0F
+/* bitmask with reserved bpools */
+#define MRVL_MUSDK_BPOOLS_RESERVED 0x07
+/* maximum number of available hifs */
+#define MRVL_MUSDK_HIFS_MAX 9
+
+#define MRVL_MAC_ADDRS_MAX 1
+#define MRVL_MATCH_LEN 16
+#define MRVL_PKT_EFFEC_OFFS (MRVL_PKT_OFFS + MV_MH_SIZE)
+/* Maximum allowable packet size */
+#define MRVL_PKT_SIZE_MAX (10240 - MV_MH_SIZE)
+
+#define MRVL_IFACE_NAME_ARG "iface"
+#define MRVL_CFG_ARG "cfg"
+
+#define MRVL_BURST_SIZE 64
+
+#define MRVL_ARP_LENGTH 28
+
+#define MRVL_COOKIE_ADDR_INVALID ~0ULL
+
+#define MRVL_COOKIE_HIGH_ADDR_SHIFT    (sizeof(pp2_cookie_t) * 8)
+#define MRVL_COOKIE_HIGH_ADDR_MASK     (~0ULL << MRVL_COOKIE_HIGH_ADDR_SHIFT)
+
+static const char * const valid_args[] = {
+       MRVL_IFACE_NAME_ARG,
+       MRVL_CFG_ARG,
+       NULL
+};
+
+static int used_hifs = MRVL_MUSDK_HIFS_RESERVED;
+static struct pp2_hif *hifs[RTE_MAX_LCORE];
+static int used_bpools[PP2_NUM_PKT_PROC] = {
+       MRVL_MUSDK_BPOOLS_RESERVED,
+       MRVL_MUSDK_BPOOLS_RESERVED
+};
+
+uint64_t cookie_addr_high = MRVL_COOKIE_ADDR_INVALID;
+
+struct mrvl_rxq {
+       struct mrvl_priv *priv;
+       struct rte_mempool *mp;
+       int queue_id;
+       int port_id;
+};
+
+struct mrvl_txq {
+       struct mrvl_priv *priv;
+       int queue_id;
+       int port_id;
+};
+
+/** Number of ports configured. */
+int mrvl_ports_nb;
+
+static inline int
+mrvl_reserve_bit(int *bitmap, int max)
+{
+       int n = sizeof(*bitmap) * 8 - __builtin_clz(*bitmap);
+
+       if (n >= max)
+               return -1;
+
+       *bitmap |= 1 << n;
+
+       return n;
+}
+
+/**
+ * Ethernet device configuration.
+ *
+ * Prepare the driver for a given number of TX and RX queues.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_dev_configure(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       int ret;
+
+       if (dev->data->dev_conf.rxmode.mq_mode != ETH_MQ_RX_NONE) {
+               RTE_LOG(INFO, PMD, "Unsupported rx multi queue mode %d\n",
+                       dev->data->dev_conf.rxmode.mq_mode);
+               return -EINVAL;
+       }
+
+       if (!dev->data->dev_conf.rxmode.hw_strip_crc) {
+               RTE_LOG(INFO, PMD,
+                       "L2 CRC stripping is always enabled in hw\n");
+               dev->data->dev_conf.rxmode.hw_strip_crc = 1;
+       }
+
+       if (dev->data->dev_conf.rxmode.hw_vlan_strip) {
+               RTE_LOG(INFO, PMD, "VLAN stripping not supported\n");
+               return -EINVAL;
+       }
+
+       if (dev->data->dev_conf.rxmode.split_hdr_size) {
+               RTE_LOG(INFO, PMD, "Split headers not supported\n");
+               return -EINVAL;
+       }
+
+       if (dev->data->dev_conf.rxmode.enable_scatter) {
+               RTE_LOG(INFO, PMD, "RX Scatter/Gather not supported\n");
+               return -EINVAL;
+       }
+
+       if (dev->data->dev_conf.rxmode.enable_lro) {
+               RTE_LOG(INFO, PMD, "LRO not supported\n");
+               return -EINVAL;
+       }
+
+       ret = mrvl_configure_rxqs(priv, dev->data->port_id,
+                                 dev->data->nb_rx_queues);
+       if (ret < 0)
+               return ret;
+
+       priv->ppio_params.outqs_params.num_outqs = dev->data->nb_tx_queues;
+       priv->nb_rx_queues = dev->data->nb_rx_queues;
+
+       return 0;
+}
+
+/**
+ * DPDK callback to bring the link up.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_dev_set_link_up(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       int ret;
+
+       ret = pp2_ppio_enable(priv->ppio);
+       if (ret)
+               return ret;
+
+       dev->data->dev_link.link_status = ETH_LINK_UP;
+
+       return ret;
+}
+
+/**
+ * DPDK callback to bring the link down.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_dev_set_link_down(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       int ret;
+
+       ret = pp2_ppio_disable(priv->ppio);
+       if (ret)
+               return ret;
+
+       dev->data->dev_link.link_status = ETH_LINK_DOWN;
+
+       return ret;
+}
+
+/**
+ * DPDK callback to start the device.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative errno value on failure.
+ */
+static int
+mrvl_dev_start(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       char match[MRVL_MATCH_LEN];
+       int ret;
+
+       snprintf(match, sizeof(match), "ppio-%d:%d",
+                priv->pp_id, priv->ppio_id);
+       priv->ppio_params.match = match;
+
+       /*
+        * Calculate the maximum bpool size for refill feature to 1.5 of the
+        * configured size. In case the bpool size will exceed this value,
+        * superfluous buffers will be removed
+        */
+       priv->bpool_max_size = priv->bpool_init_size +
+                             (priv->bpool_init_size >> 1);
+       /*
+        * Calculate the minimum bpool size for refill feature as follows:
+        * 2 default burst sizes multiply by number of rx queues.
+        * If the bpool size will be below this value, new buffers will
+        * be added to the pool.
+        */
+       priv->bpool_min_size = priv->nb_rx_queues * MRVL_BURST_SIZE * 2;
+
+       ret = pp2_ppio_init(&priv->ppio_params, &priv->ppio);
+       if (ret)
+               return ret;
+
+       /* For default QoS config, don't start classifier. */
+       if (mrvl_qos_cfg) {
+               ret = mrvl_start_qos_mapping(priv);
+               if (ret) {
+                       pp2_ppio_deinit(priv->ppio);
+                       return ret;
+               }
+       }
+
+       ret = mrvl_dev_set_link_up(dev);
+       if (ret)
+               goto out;
+
+       return 0;
+out:
+       pp2_ppio_deinit(priv->ppio);
+       return ret;
+}
+
+/**
+ * Flush receive queues.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ */
+static void
+mrvl_flush_rx_queues(struct rte_eth_dev *dev)
+{
+       int i;
+
+       RTE_LOG(INFO, PMD, "Flushing rx queues\n");
+       for (i = 0; i < dev->data->nb_rx_queues; i++) {
+               int ret, num;
+
+               do {
+                       struct mrvl_rxq *q = dev->data->rx_queues[i];
+                       struct pp2_ppio_desc descs[MRVL_PP2_RXD_MAX];
+
+                       num = MRVL_PP2_RXD_MAX;
+                       ret = pp2_ppio_recv(q->priv->ppio,
+                                           q->priv->rxq_map[q->queue_id].tc,
+                                           q->priv->rxq_map[q->queue_id].inq,
+                                           descs, (uint16_t *)&num);
+               } while (ret == 0 && num);
+       }
+}
+
+/**
+ * Flush hardware bpool (buffer-pool).
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ */
+static void
+mrvl_flush_bpool(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       uint32_t num;
+       int ret;
+
+       ret = pp2_bpool_get_num_buffs(priv->bpool, &num);
+       if (ret) {
+               RTE_LOG(ERR, PMD, "Failed to get bpool buffers number\n");
+               return;
+       }
+
+       while (num--) {
+               struct pp2_buff_inf inf;
+               uint64_t addr;
+
+               ret = pp2_bpool_get_buff(hifs[rte_lcore_id()], priv->bpool,
+                                        &inf);
+               if (ret)
+                       break;
+
+               addr = cookie_addr_high | inf.cookie;
+               rte_pktmbuf_free((struct rte_mbuf *)addr);
+       }
+}
+
+/**
+ * DPDK callback to stop the device.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ */
+static void
+mrvl_dev_stop(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+
+       mrvl_dev_set_link_down(dev);
+       mrvl_flush_rx_queues(dev);
+       if (priv->qos_tbl)
+               pp2_cls_qos_tbl_deinit(priv->qos_tbl);
+       pp2_ppio_deinit(priv->ppio);
+       priv->ppio = NULL;
+}
+
+/**
+ * DPDK callback to close the device.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ */
+static void
+mrvl_dev_close(struct rte_eth_dev *dev)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       size_t i;
+
+       for (i = 0; i < priv->ppio_params.inqs_params.num_tcs; ++i) {
+               struct pp2_ppio_tc_params *tc_params =
+                       &priv->ppio_params.inqs_params.tcs_params[i];
+
+               if (tc_params->inqs_params) {
+                       rte_free(tc_params->inqs_params);
+                       tc_params->inqs_params = NULL;
+               }
+       }
+
+       mrvl_flush_bpool(dev);
+}
+
+/**
+ * DPDK callback to set the primary MAC address.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param mac_addr
+ *   MAC address to register.
+ */
+static void
+mrvl_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+
+       pp2_ppio_set_mac_addr(priv->ppio, mac_addr->addr_bytes);
+       /*
+        * TODO
+        * Port stops sending packets if pp2_ppio_set_mac_addr()
+        * was called after pp2_ppio_enable(). As a quick fix issue
+        * enable port once again.
+        */
+       pp2_ppio_enable(priv->ppio);
+}
+
+/**
+ * DPDK callback to get information about the device.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure (unused).
+ * @param info
+ *   Info structure output buffer.
+ */
+static void
+mrvl_dev_infos_get(struct rte_eth_dev *dev __rte_unused,
+                  struct rte_eth_dev_info *info)
+{
+       info->max_rx_queues = MRVL_PP2_RXQ_MAX;
+       info->max_tx_queues = MRVL_PP2_TXQ_MAX;
+       info->max_mac_addrs = MRVL_MAC_ADDRS_MAX;
+
+       info->rx_desc_lim.nb_max = MRVL_PP2_RXD_MAX;
+       info->rx_desc_lim.nb_min = MRVL_PP2_RXD_MIN;
+       info->rx_desc_lim.nb_align = MRVL_PP2_RXD_ALIGN;
+
+       info->tx_desc_lim.nb_max = MRVL_PP2_TXD_MAX;
+       info->tx_desc_lim.nb_min = MRVL_PP2_TXD_MIN;
+       info->tx_desc_lim.nb_align = MRVL_PP2_TXD_ALIGN;
+
+       /* By default packets are dropped if no descriptors are available */
+       info->default_rxconf.rx_drop_en = 1;
+
+       info->max_rx_pktlen = MRVL_PKT_SIZE_MAX;
+}
+
+/**
+ * DPDK callback to get information about specific receive queue.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param rx_queue_id
+ *   Receive queue index.
+ * @param qinfo
+ *   Receive queue information structure.
+ */
+static void mrvl_rxq_info_get(struct rte_eth_dev *dev, uint16_t rx_queue_id,
+                             struct rte_eth_rxq_info *qinfo)
+{
+       struct mrvl_rxq *q = dev->data->rx_queues[rx_queue_id];
+       struct mrvl_priv *priv = dev->data->dev_private;
+       int inq = priv->rxq_map[rx_queue_id].inq;
+       int tc = priv->rxq_map[rx_queue_id].tc;
+       struct pp2_ppio_tc_params *tc_params =
+               &priv->ppio_params.inqs_params.tcs_params[tc];
+
+       qinfo->mp = q->mp;
+       qinfo->nb_desc = tc_params->inqs_params[inq].size;
+}
+
+/**
+ * DPDK callback to get information about specific transmit queue.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param tx_queue_id
+ *   Transmit queue index.
+ * @param qinfo
+ *   Transmit queue information structure.
+ */
+static void mrvl_txq_info_get(struct rte_eth_dev *dev, uint16_t tx_queue_id,
+                             struct rte_eth_txq_info *qinfo)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+
+       qinfo->nb_desc =
+               priv->ppio_params.outqs_params.outqs_params[tx_queue_id].size;
+}
+
+/**
+ * Release buffers to hardware bpool (buffer-pool)
+ *
+ * @param rxq
+ *   Receive queue pointer.
+ * @param num
+ *   Number of buffers to release to bpool.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_fill_bpool(struct mrvl_rxq *rxq, int num)
+{
+       struct buff_release_entry entries[MRVL_PP2_TXD_MAX];
+       struct rte_mbuf *mbufs[MRVL_PP2_TXD_MAX];
+       int i, ret;
+       unsigned int core_id = rte_lcore_id();
+       struct pp2_hif *hif = hifs[core_id];
+       struct pp2_bpool *bpool = rxq->priv->bpool;
+
+       ret = rte_pktmbuf_alloc_bulk(rxq->mp, mbufs, num);
+       if (ret)
+               return ret;
+
+       if (cookie_addr_high == MRVL_COOKIE_ADDR_INVALID)
+               cookie_addr_high =
+                       (uint64_t)mbufs[0] & MRVL_COOKIE_HIGH_ADDR_MASK;
+
+       for (i = 0; i < num; i++) {
+               if (((uint64_t)mbufs[i] & MRVL_COOKIE_HIGH_ADDR_MASK)
+                       != cookie_addr_high) {
+                       RTE_LOG(ERR, PMD,
+                               "mbuf virtual addr high 0x%lx out of range\n",
+                               (uint64_t)mbufs[i] >> 32);
+                       goto out;
+               }
+
+               entries[i].buff.addr =
+                       rte_mbuf_data_dma_addr_default(mbufs[i]);
+               entries[i].buff.cookie = (pp2_cookie_t)(uint64_t)mbufs[i];
+               entries[i].bpool = bpool;
+       }
+
+       pp2_bpool_put_buffs(hif, entries, (uint16_t *)&i);
+
+       if (i != num)
+               goto out;
+
+       return 0;
+out:
+       for (; i < num; i++)
+               rte_pktmbuf_free(mbufs[i]);
+
+       return -1;
+}
+
+/**
+ * DPDK callback to configure the receive queue.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param idx
+ *   RX queue index.
+ * @param desc
+ *   Number of descriptors to configure in queue.
+ * @param socket
+ *   NUMA socket on which memory must be allocated.
+ * @param conf
+ *   Thresholds parameters (unused_).
+ * @param mp
+ *   Memory pool for buffer allocations.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
+                   unsigned int socket,
+                   const struct rte_eth_rxconf *conf __rte_unused,
+                   struct rte_mempool *mp)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       struct mrvl_rxq *rxq;
+       uint32_t min_size,
+                max_rx_pkt_len = dev->data->dev_conf.rxmode.max_rx_pkt_len;
+       int ret, tc, inq;
+
+       if (priv->rxq_map[idx].tc == MRVL_UNKNOWN_TC) {
+               /*
+                * Unknown TC mapping, mapping will not have a correct queue.
+                */
+               RTE_LOG(ERR, PMD, "Unknown TC mapping for queue %hu eth%hhu\n",
+                       idx, priv->ppio_id);
+               return -EFAULT;
+       }
+
+       min_size = rte_pktmbuf_data_room_size(mp) - RTE_PKTMBUF_HEADROOM -
+                  MRVL_PKT_EFFEC_OFFS;
+       if (min_size < max_rx_pkt_len) {
+               RTE_LOG(ERR, PMD,
+                       "Mbuf size must be increased to %u bytes to hold up to %u bytes of data.\n",
+                       max_rx_pkt_len + RTE_PKTMBUF_HEADROOM +
+                       MRVL_PKT_EFFEC_OFFS,
+                       max_rx_pkt_len);
+               return -EINVAL;
+       }
+
+       if (dev->data->rx_queues[idx]) {
+               rte_free(dev->data->rx_queues[idx]);
+               dev->data->rx_queues[idx] = NULL;
+       }
+
+       rxq = rte_zmalloc_socket("rxq", sizeof(*rxq), 0, socket);
+       if (!rxq)
+               return -ENOMEM;
+
+       rxq->priv = priv;
+       rxq->mp = mp;
+       rxq->queue_id = idx;
+       rxq->port_id = dev->data->port_id;
+
+       tc = priv->rxq_map[rxq->queue_id].tc,
+       inq = priv->rxq_map[rxq->queue_id].inq;
+       priv->ppio_params.inqs_params.tcs_params[tc].inqs_params[inq].size =
+               desc;
+
+       ret = mrvl_fill_bpool(rxq, desc);
+       if (ret) {
+               rte_free(rxq);
+               return ret;
+       }
+
+       priv->bpool_init_size += desc;
+
+       dev->data->rx_queues[idx] = rxq;
+
+       return 0;
+}
+
+/**
+ * DPDK callback to release the receive queue.
+ *
+ * @param rxq
+ *   Generic receive queue pointer.
+ */
+static void
+mrvl_rx_queue_release(void *rxq)
+{
+       struct mrvl_rxq *q = rxq;
+       struct pp2_ppio_tc_params *tc_params;
+       int i, num, tc, inq;
+
+       if (!q)
+               return;
+
+       tc = q->priv->rxq_map[q->queue_id].tc;
+       inq = q->priv->rxq_map[q->queue_id].inq;
+       tc_params = &q->priv->ppio_params.inqs_params.tcs_params[tc];
+       num = tc_params->inqs_params[inq].size;
+       for (i = 0; i < num; i++) {
+               struct pp2_buff_inf inf;
+               uint64_t addr;
+
+               pp2_bpool_get_buff(hifs[rte_lcore_id()], q->priv->bpool, &inf);
+               addr = cookie_addr_high | inf.cookie;
+               rte_pktmbuf_free((struct rte_mbuf *)addr);
+       }
+
+       rte_free(q);
+}
+
+/**
+ * DPDK callback to configure the transmit queue.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param idx
+ *   Transmit queue index.
+ * @param desc
+ *   Number of descriptors to configure in the queue.
+ * @param socket
+ *   NUMA socket on which memory must be allocated.
+ * @param conf
+ *   Thresholds parameters (unused).
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_tx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
+                   unsigned int socket,
+                   const struct rte_eth_txconf *conf __rte_unused)
+{
+       struct mrvl_priv *priv = dev->data->dev_private;
+       struct mrvl_txq *txq;
+
+       if (dev->data->tx_queues[idx]) {
+               rte_free(dev->data->tx_queues[idx]);
+               dev->data->tx_queues[idx] = NULL;
+       }
+
+       txq = rte_zmalloc_socket("txq", sizeof(*txq), 0, socket);
+       if (!txq)
+               return -ENOMEM;
+
+       txq->priv = priv;
+       txq->queue_id = idx;
+       txq->port_id = dev->data->port_id;
+       dev->data->tx_queues[idx] = txq;
+
+       priv->ppio_params.outqs_params.outqs_params[idx].size = desc;
+       priv->ppio_params.outqs_params.outqs_params[idx].weight = 1;
+
+       return 0;
+}
+
+/**
+ * DPDK callback to release the transmit queue.
+ *
+ * @param txq
+ *   Generic transmit queue pointer.
+ */
+static void
+mrvl_tx_queue_release(void *txq)
+{
+       struct mrvl_txq *q = txq;
+
+       if (!q)
+               return;
+
+       rte_free(q);
+}
+
+static const struct eth_dev_ops mrvl_ops = {
+       .dev_configure = mrvl_dev_configure,
+       .dev_start = mrvl_dev_start,
+       .dev_stop = mrvl_dev_stop,
+       .dev_set_link_up = mrvl_dev_set_link_up,
+       .dev_set_link_down = mrvl_dev_set_link_down,
+       .dev_close = mrvl_dev_close,
+       .mac_addr_set = mrvl_mac_addr_set,
+       .dev_infos_get = mrvl_dev_infos_get,
+       .rxq_info_get = mrvl_rxq_info_get,
+       .txq_info_get = mrvl_txq_info_get,
+       .rx_queue_setup = mrvl_rx_queue_setup,
+       .rx_queue_release = mrvl_rx_queue_release,
+       .tx_queue_setup = mrvl_tx_queue_setup,
+       .tx_queue_release = mrvl_tx_queue_release,
+};
+
+/**
+ * Initialize packet processor.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_init_pp2(void)
+{
+       struct pp2_init_params init_params;
+
+       memset(&init_params, 0, sizeof(init_params));
+       init_params.hif_reserved_map = MRVL_MUSDK_HIFS_RESERVED;
+       init_params.bm_pool_reserved_map = MRVL_MUSDK_BPOOLS_RESERVED;
+
+       return pp2_init(&init_params);
+}
+
+/**
+ * Deinitialize packet processor.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static void
+mrvl_deinit_pp2(void)
+{
+       pp2_deinit();
+}
+
+/**
+ * Create private device structure.
+ *
+ * @param dev_name
+ *   Pointer to the port name passed in the initialization parameters.
+ *
+ * @return
+ *   Pointer to the newly allocated private device structure.
+ */
+static struct mrvl_priv *
+mrvl_priv_create(const char *dev_name)
+{
+       struct pp2_bpool_params bpool_params;
+       char match[MRVL_MATCH_LEN];
+       struct mrvl_priv *priv;
+       int ret, bpool_bit;
+
+       priv = rte_zmalloc_socket(dev_name, sizeof(*priv), 0, rte_socket_id());
+       if (!priv)
+               return NULL;
+
+       ret = pp2_netdev_get_ppio_info((char *)(uintptr_t)dev_name,
+                                      &priv->pp_id, &priv->ppio_id);
+       if (ret)
+               goto out_free_priv;
+
+       bpool_bit = mrvl_reserve_bit(&used_bpools[priv->pp_id],
+                                    PP2_BPOOL_NUM_POOLS);
+       if (bpool_bit < 0)
+               goto out_free_priv;
+       priv->bpool_bit = bpool_bit;
+
+       snprintf(match, sizeof(match), "pool-%d:%d", priv->pp_id,
+                priv->bpool_bit);
+       memset(&bpool_params, 0, sizeof(bpool_params));
+       bpool_params.match = match;
+       bpool_params.buff_len = MRVL_PKT_SIZE_MAX + MRVL_PKT_EFFEC_OFFS;
+       ret = pp2_bpool_init(&bpool_params, &priv->bpool);
+       if (ret)
+               goto out_clear_bpool_bit;
+
+       priv->ppio_params.type = PP2_PPIO_T_NIC;
+
+       return priv;
+out_clear_bpool_bit:
+       used_bpools[priv->pp_id] &= ~(1 << priv->bpool_bit);
+out_free_priv:
+       rte_free(priv);
+       return NULL;
+}
+
+/**
+ * Create device representing Ethernet port.
+ *
+ * @param name
+ *   Pointer to the port's name.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_eth_dev_create(struct rte_vdev_device *vdev, const char *name)
+{
+       int ret, fd = socket(AF_INET, SOCK_DGRAM, 0);
+       struct rte_eth_dev *eth_dev;
+       struct mrvl_priv *priv;
+       struct ifreq req;
+
+       eth_dev = rte_eth_dev_allocate(name);
+       if (!eth_dev)
+               return -ENOMEM;
+
+       priv = mrvl_priv_create(name);
+       if (!priv) {
+               ret = -ENOMEM;
+               goto out_free_dev;
+       }
+
+       eth_dev->data->mac_addrs =
+               rte_zmalloc("mac_addrs",
+                           ETHER_ADDR_LEN * MRVL_MAC_ADDRS_MAX, 0);
+       if (!eth_dev->data->mac_addrs) {
+               RTE_LOG(ERR, PMD, "Failed to allocate space for eth addrs\n");
+               ret = -ENOMEM;
+               goto out_free_priv;
+       }
+
+       memset(&req, 0, sizeof(req));
+       strcpy(req.ifr_name, name);
+       ret = ioctl(fd, SIOCGIFHWADDR, &req);
+       if (ret)
+               goto out_free_mac;
+
+       memcpy(eth_dev->data->mac_addrs[0].addr_bytes,
+              req.ifr_addr.sa_data, ETHER_ADDR_LEN);
+
+       eth_dev->data->dev_private = priv;
+       eth_dev->device = &vdev->device;
+       eth_dev->dev_ops = &mrvl_ops;
+
+       return 0;
+out_free_mac:
+       rte_free(eth_dev->data->mac_addrs);
+out_free_dev:
+       rte_eth_dev_release_port(eth_dev);
+out_free_priv:
+       rte_free(priv);
+
+       return ret;
+}
+
+/**
+ * Cleanup previously created device representing Ethernet port.
+ *
+ * @param name
+ *   Pointer to the port name.
+ */
+static void
+mrvl_eth_dev_destroy(const char *name)
+{
+       struct rte_eth_dev *eth_dev;
+       struct mrvl_priv *priv;
+
+       eth_dev = rte_eth_dev_allocated(name);
+       if (!eth_dev)
+               return;
+
+       priv = eth_dev->data->dev_private;
+       pp2_bpool_deinit(priv->bpool);
+       rte_free(priv);
+       rte_free(eth_dev->data->mac_addrs);
+       rte_eth_dev_release_port(eth_dev);
+}
+
+/**
+ * Callback used by rte_kvargs_process() during argument parsing.
+ *
+ * @param key
+ *   Pointer to the parsed key (unused).
+ * @param value
+ *   Pointer to the parsed value.
+ * @param extra_args
+ *   Pointer to the extra arguments which contains address of the
+ *   table of pointers to parsed interface names.
+ *
+ * @return
+ *   Always 0.
+ */
+static int
+mrvl_get_ifnames(const char *key __rte_unused, const char *value,
+                void *extra_args)
+{
+       const char **ifnames = extra_args;
+
+       ifnames[mrvl_ports_nb++] = value;
+
+       return 0;
+}
+
+/**
+ * Initialize per-lcore MUSDK hardware interfaces (hifs).
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+mrvl_init_hifs(void)
+{
+       struct pp2_hif_params params;
+       char match[MRVL_MATCH_LEN];
+       int i, ret;
+
+       RTE_LCORE_FOREACH(i) {
+               ret = mrvl_reserve_bit(&used_hifs, MRVL_MUSDK_HIFS_MAX);
+               if (ret < 0)
+                       return ret;
+
+               snprintf(match, sizeof(match), "hif-%d", ret);
+               memset(&params, 0, sizeof(params));
+               params.match = match;
+               params.out_size = MRVL_PP2_AGGR_TXQD_MAX;
+               ret = pp2_hif_init(&params, &hifs[i]);
+               if (ret) {
+                       RTE_LOG(ERR, PMD, "Failed to initialize hif %d\n", i);
+                       return ret;
+               }
+       }
+
+       return 0;
+}
+
+/**
+ * Deinitialize per-lcore MUSDK hardware interfaces (hifs).
+ */
+static void
+mrvl_deinit_hifs(void)
+{
+       int i;
+
+       RTE_LCORE_FOREACH(i) {
+               if (hifs[i])
+                       pp2_hif_deinit(hifs[i]);
+       }
+}
+
+/**
+ * DPDK callback to register the virtual device.
+ *
+ * @param vdev
+ *   Pointer to the virtual device.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+rte_pmd_mrvl_probe(struct rte_vdev_device *vdev)
+{
+       struct rte_kvargs *kvlist;
+       const char *ifnames[PP2_NUM_ETH_PPIO * PP2_NUM_PKT_PROC];
+       int ret = -EINVAL;
+       uint32_t i, ifnum, cfgnum;
+       const char *params;
+
+       params = rte_vdev_device_args(vdev);
+       if (!params)
+               return -EINVAL;
+
+       kvlist = rte_kvargs_parse(params, valid_args);
+       if (!kvlist)
+               return -EINVAL;
+
+       ifnum = rte_kvargs_count(kvlist, MRVL_IFACE_NAME_ARG);
+       if (ifnum > RTE_DIM(ifnames))
+               goto out_free_kvlist;
+
+       rte_kvargs_process(kvlist, MRVL_IFACE_NAME_ARG,
+                          mrvl_get_ifnames, &ifnames);
+
+       cfgnum = rte_kvargs_count(kvlist, MRVL_CFG_ARG);
+       if (cfgnum > 1) {
+               RTE_LOG(ERR, PMD, "Cannot handle more than one config file!\n");
+               goto out_free_kvlist;
+       } else if (cfgnum == 1) {
+               rte_kvargs_process(kvlist, MRVL_CFG_ARG,
+                                  mrvl_get_qoscfg, &mrvl_qos_cfg);
+       }
+
+       /*
+        * ret == -EEXIST is correct, it means DMA
+        * has been already initialized (by another PMD).
+        */
+       ret = mv_sys_dma_mem_init(RTE_MRVL_MUSDK_DMA_MEMSIZE);
+       if (ret < 0 && ret != -EEXIST)
+               goto out_free_kvlist;
+
+       ret = mrvl_init_pp2();
+       if (ret) {
+               RTE_LOG(ERR, PMD, "Failed to init PP!\n");
+               goto out_deinit_dma;
+       }
+
+       ret = mrvl_init_hifs();
+       if (ret)
+               goto out_deinit_hifs;
+
+       for (i = 0; i < ifnum; i++) {
+               RTE_LOG(INFO, PMD, "Creating %s\n", ifnames[i]);
+               ret = mrvl_eth_dev_create(vdev, ifnames[i]);
+               if (ret)
+                       goto out_cleanup;
+       }
+
+       rte_kvargs_free(kvlist);
+
+       return 0;
+out_cleanup:
+       for (; i > 0; i--)
+               mrvl_eth_dev_destroy(ifnames[i]);
+out_deinit_hifs:
+       mrvl_deinit_hifs();
+       mrvl_deinit_pp2();
+out_deinit_dma:
+       mv_sys_dma_mem_destroy();
+out_free_kvlist:
+       rte_kvargs_free(kvlist);
+
+       return ret;
+}
+
+/**
+ * DPDK callback to remove virtual device.
+ *
+ * @param vdev
+ *   Pointer to the removed virtual device.
+ *
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int
+rte_pmd_mrvl_remove(struct rte_vdev_device *vdev)
+{
+       int i;
+       const char *name;
+
+       name = rte_vdev_device_name(vdev);
+       if (!name)
+               return -EINVAL;
+
+       RTE_LOG(INFO, PMD, "Removing %s\n", name);
+
+       for (i = 0; i < rte_eth_dev_count(); i++) {
+               char ifname[RTE_ETH_NAME_MAX_LEN];
+
+               rte_eth_dev_get_name_by_port(i, ifname);
+               mrvl_eth_dev_destroy(ifname);
+       }
+
+       mrvl_deinit_hifs();
+       mrvl_deinit_pp2();
+       mv_sys_dma_mem_destroy();
+
+       return 0;
+}
+
+static struct rte_vdev_driver pmd_mrvl_drv = {
+       .probe = rte_pmd_mrvl_probe,
+       .remove = rte_pmd_mrvl_remove,
+};
+
+RTE_PMD_REGISTER_VDEV(net_mrvl, pmd_mrvl_drv);
+RTE_PMD_REGISTER_ALIAS(net_mrvl, eth_mrvl);
diff --git a/drivers/net/mrvl/mrvl_ethdev.h b/drivers/net/mrvl/mrvl_ethdev.h
new file mode 100644 (file)
index 0000000..626cfaa
--- /dev/null
@@ -0,0 +1,100 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2017 Semihalf. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Semihalf nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   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
+ *   OWNER 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.
+ */
+
+#ifndef _MRVL_ETHDEV_H_
+#define _MRVL_ETHDEV_H_
+
+#include <drivers/mv_pp2_cls.h>
+#include <drivers/mv_pp2_ppio.h>
+
+/** Maximum number of rx queues per port */
+#define MRVL_PP2_RXQ_MAX 32
+
+/** Maximum number of tx queues per port */
+#define MRVL_PP2_TXQ_MAX 8
+
+/** Minimum number of descriptors in tx queue */
+#define MRVL_PP2_TXD_MIN 16
+
+/** Maximum number of descriptors in tx queue */
+#define MRVL_PP2_TXD_MAX 2048
+
+/** Tx queue descriptors alignment */
+#define MRVL_PP2_TXD_ALIGN 16
+
+/** Minimum number of descriptors in rx queue */
+#define MRVL_PP2_RXD_MIN 16
+
+/** Maximum number of descriptors in rx queue */
+#define MRVL_PP2_RXD_MAX 2048
+
+/** Rx queue descriptors alignment */
+#define MRVL_PP2_RXD_ALIGN 16
+
+/** Maximum number of descriptors in tx aggregated queue */
+#define MRVL_PP2_AGGR_TXQD_MAX 2048
+
+/** Maximum number of Traffic Classes. */
+#define MRVL_PP2_TC_MAX 8
+
+/** Packet offset inside RX buffer. */
+#define MRVL_PKT_OFFS 64
+
+struct mrvl_priv {
+       /* Hot fields, used in fast path. */
+       struct pp2_bpool *bpool;  /**< BPool pointer */
+       struct pp2_ppio *ppio;    /**< Port handler pointer */
+       uint16_t bpool_max_size;  /**< BPool maximum size */
+       uint16_t bpool_min_size;  /**< BPool minimum size  */
+       uint16_t bpool_init_size; /**< Configured BPool size  */
+
+       /** Mapping for DPDK rx queue->(TC, MRVL relative inq) */
+       struct {
+               uint8_t tc;  /**< Traffic Class */
+               uint8_t inq; /**< Relative in-queue number */
+       } rxq_map[MRVL_PP2_RXQ_MAX] __rte_cache_aligned;
+
+       /* Configuration data, used sporadically. */
+       uint8_t pp_id;
+       uint8_t ppio_id;
+       uint8_t bpool_bit;
+
+       struct pp2_ppio_params ppio_params;
+       struct pp2_cls_qos_tbl_params qos_tbl_params;
+       struct pp2_cls_tbl *qos_tbl;
+       uint16_t nb_rx_queues;
+};
+
+/** Number of ports configured. */
+extern int mrvl_ports_nb;
+
+#endif /* _MRVL_ETHDEV_H_ */
diff --git a/drivers/net/mrvl/mrvl_qos.c b/drivers/net/mrvl/mrvl_qos.c
new file mode 100644 (file)
index 0000000..796509b
--- /dev/null
@@ -0,0 +1,633 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2017 Semihalf. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Semihalf nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   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
+ *   OWNER 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.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <rte_common.h>
+#include <rte_cfgfile.h>
+#include <rte_log.h>
+#include <rte_lcore.h>
+#include <rte_malloc.h>
+#include <rte_string_fns.h>
+
+/* Unluckily, container_of is defined by both DPDK and MUSDK,
+ * we'll declare only one version.
+ *
+ * Note that it is not used in this PMD anyway.
+ */
+#ifdef container_of
+#undef container_of
+#endif
+
+#include "mrvl_qos.h"
+
+/* Parsing tokens. Defined conveniently, so that any correction is easy. */
+#define MRVL_TOK_DEFAULT "default"
+#define MRVL_TOK_DEFAULT_TC "default_tc"
+#define MRVL_TOK_DSCP "dscp"
+#define MRVL_TOK_MAPPING_PRIORITY "mapping_priority"
+#define MRVL_TOK_IP "ip"
+#define MRVL_TOK_IP_VLAN "ip/vlan"
+#define MRVL_TOK_PCP "pcp"
+#define MRVL_TOK_PORT "port"
+#define MRVL_TOK_RXQ "rxq"
+#define MRVL_TOK_SP "SP"
+#define MRVL_TOK_TC "tc"
+#define MRVL_TOK_TXQ "txq"
+#define MRVL_TOK_VLAN "vlan"
+#define MRVL_TOK_VLAN_IP "vlan/ip"
+#define MRVL_TOK_WEIGHT "weight"
+
+/** Number of tokens in range a-b = 2. */
+#define MAX_RNG_TOKENS 2
+
+/** Maximum possible value of PCP. */
+#define MAX_PCP 7
+
+/** Maximum possible value of DSCP. */
+#define MAX_DSCP 63
+
+/** Global QoS configuration. */
+struct mrvl_qos_cfg *mrvl_qos_cfg;
+
+/**
+ * Convert string to uint32_t with extra checks for result correctness.
+ *
+ * @param string String to convert.
+ * @param val Conversion result.
+ * @returns 0 in case of success, negative value otherwise.
+ */
+static int
+get_val_securely(const char *string, uint32_t *val)
+{
+       char *endptr;
+       size_t len = strlen(string);
+
+       if (len == 0)
+               return -1;
+
+       *val = strtoul(string, &endptr, 0);
+       if (errno != 0 || RTE_PTR_DIFF(endptr, string) != len)
+               return -2;
+
+       return 0;
+}
+
+/**
+ * Read out-queue configuration from file.
+ *
+ * @param file Path to the configuration file.
+ * @param port Port number.
+ * @param outq Out queue number.
+ * @param cfg Pointer to the Marvell QoS configuration structure.
+ * @returns 0 in case of success, negative value otherwise.
+ */
+static int
+get_outq_cfg(struct rte_cfgfile *file, int port, int outq,
+               struct mrvl_qos_cfg *cfg)
+{
+       char sec_name[32];
+       const char *entry;
+       uint32_t val;
+
+       snprintf(sec_name, sizeof(sec_name), "%s %d %s %d",
+               MRVL_TOK_PORT, port, MRVL_TOK_TXQ, outq);
+
+       /* Skip non-existing */
+       if (rte_cfgfile_num_sections(file, sec_name, strlen(sec_name)) <= 0)
+               return 0;
+
+       entry = rte_cfgfile_get_entry(file, sec_name,
+                       MRVL_TOK_WEIGHT);
+       if (entry) {
+               if (get_val_securely(entry, &val) < 0)
+                       return -1;
+               cfg->port[port].outq[outq].weight = (uint8_t)val;
+       }
+
+       return 0;
+}
+
+/**
+ * Gets multiple-entry values and places them in table.
+ *
+ * Entry can be anything, e.g. "1 2-3 5 6 7-9". This needs to be converted to
+ * table entries, respectively: {1, 2, 3, 5, 6, 7, 8, 9}.
+ * As all result table's elements are always 1-byte long, we
+ * won't overcomplicate the function, but we'll keep API generic,
+ * check if someone hasn't changed element size and make it simple
+ * to extend to other sizes.
+ *
+ * This function is purely utilitary, it does not print any error, only returns
+ * different error numbers.
+ *
+ * @param entry[in] Values string to parse.
+ * @param tab[out] Results table.
+ * @param elem_sz[in] Element size (in bytes).
+ * @param max_elems[in] Number of results table elements available.
+ * @param max val[in] Maximum value allowed.
+ * @returns Number of correctly parsed elements in case of success.
+ * @retval -1 Wrong element size.
+ * @retval -2 More tokens than result table allows.
+ * @retval -3 Wrong range syntax.
+ * @retval -4 Wrong range values.
+ * @retval -5 Maximum value exceeded.
+ */
+static int
+get_entry_values(const char *entry, uint8_t *tab,
+       size_t elem_sz, uint8_t max_elems, uint8_t max_val)
+{
+       /* There should not be more tokens than max elements.
+        * Add 1 for error trap.
+        */
+       char *tokens[max_elems + 1];
+
+       /* Begin, End + error trap = 3. */
+       char *rng_tokens[MAX_RNG_TOKENS + 1];
+       long beg, end;
+       uint32_t token_val;
+       int nb_tokens, nb_rng_tokens;
+       int i;
+       int values = 0;
+       char val;
+       char entry_cpy[CFG_VALUE_LEN];
+
+       if (elem_sz != 1)
+               return -1;
+
+       /* Copy the entry to safely use rte_strsplit(). */
+       snprintf(entry_cpy, RTE_DIM(entry_cpy), "%s", entry);
+
+       /*
+        * If there are more tokens than array size, rte_strsplit will
+        * not return error, just array size.
+        */
+       nb_tokens = rte_strsplit(entry_cpy, strlen(entry_cpy),
+               tokens, max_elems + 1, ' ');
+
+       /* Quick check, will be refined later. */
+       if (nb_tokens > max_elems)
+               return -2;
+
+       for (i = 0; i < nb_tokens; ++i) {
+               if (strchr(tokens[i], '-') != NULL) {
+                       /*
+                        * Split to begin and end tokens.
+                        * We want to catch error cases too, thus we leave
+                        * option for number of tokens to be more than 2.
+                        */
+                       nb_rng_tokens = rte_strsplit(tokens[i],
+                                       strlen(tokens[i]), rng_tokens,
+                                       RTE_DIM(rng_tokens), '-');
+                       if (nb_rng_tokens != 2)
+                               return -3;
+
+                       /* Range and sanity checks. */
+                       if (get_val_securely(rng_tokens[0], &token_val) < 0)
+                               return -4;
+                       beg = (char)token_val;
+                       if (get_val_securely(rng_tokens[1], &token_val) < 0)
+                               return -4;
+                       end = (char)token_val;
+                       if (beg < 0 || beg > UCHAR_MAX ||
+                               end < 0 || end > UCHAR_MAX || end < beg)
+                               return -4;
+
+                       for (val = beg; val <= end; ++val) {
+                               if (val > max_val)
+                                       return -5;
+
+                               *tab = val;
+                               tab = RTE_PTR_ADD(tab, elem_sz);
+                               ++values;
+                               if (values >= max_elems)
+                                       return -2;
+                       }
+               } else {
+                       /* Single values. */
+                       if (get_val_securely(tokens[i], &token_val) < 0)
+                               return -5;
+                       val = (char)token_val;
+                       if (val > max_val)
+                               return -5;
+
+                       *tab = val;
+                       tab = RTE_PTR_ADD(tab, elem_sz);
+                       ++values;
+                       if (values >= max_elems)
+                               return -2;
+               }
+       }
+
+       return values;
+}
+
+/**
+ * Parse Traffic Class'es mapping configuration.
+ *
+ * @param file Config file handle.
+ * @param port Which port to look for.
+ * @param tc Which Traffic Class to look for.
+ * @param cfg[out] Parsing results.
+ * @returns 0 in case of success, negative value otherwise.
+ */
+static int
+parse_tc_cfg(struct rte_cfgfile *file, int port, int tc,
+               struct mrvl_qos_cfg *cfg)
+{
+       char sec_name[32];
+       const char *entry;
+       int n;
+
+       snprintf(sec_name, sizeof(sec_name), "%s %d %s %d",
+               MRVL_TOK_PORT, port, MRVL_TOK_TC, tc);
+
+       /* Skip non-existing */
+       if (rte_cfgfile_num_sections(file, sec_name, strlen(sec_name)) <= 0)
+               return 0;
+
+       entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_RXQ);
+       if (entry) {
+               n = get_entry_values(entry,
+                       cfg->port[port].tc[tc].inq,
+                       sizeof(cfg->port[port].tc[tc].inq[0]),
+                       RTE_DIM(cfg->port[port].tc[tc].inq),
+                       MRVL_PP2_RXQ_MAX);
+               if (n < 0) {
+                       RTE_LOG(ERR, PMD, "Error %d while parsing: %s\n",
+                               n, entry);
+                       return n;
+               }
+               cfg->port[port].tc[tc].inqs = n;
+       }
+
+       entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PCP);
+       if (entry) {
+               n = get_entry_values(entry,
+                       cfg->port[port].tc[tc].pcp,
+                       sizeof(cfg->port[port].tc[tc].pcp[0]),
+                       RTE_DIM(cfg->port[port].tc[tc].pcp),
+                       MAX_PCP);
+               if (n < 0) {
+                       RTE_LOG(ERR, PMD, "Error %d while parsing: %s\n",
+                               n, entry);
+                       return n;
+               }
+               cfg->port[port].tc[tc].pcps = n;
+       }
+
+       entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_DSCP);
+       if (entry) {
+               n = get_entry_values(entry,
+                       cfg->port[port].tc[tc].dscp,
+                       sizeof(cfg->port[port].tc[tc].dscp[0]),
+                       RTE_DIM(cfg->port[port].tc[tc].dscp),
+                       MAX_DSCP);
+               if (n < 0) {
+                       RTE_LOG(ERR, PMD, "Error %d while parsing: %s\n",
+                               n, entry);
+                       return n;
+               }
+               cfg->port[port].tc[tc].dscps = n;
+       }
+       return 0;
+}
+
+/**
+ * Parse QoS configuration - rte_kvargs_process handler.
+ *
+ * Opens configuration file and parses its content.
+ *
+ * @param key Unused.
+ * @param path Path to config file.
+ * @param extra_args Pointer to configuration structure.
+ * @returns 0 in case of success, exits otherwise.
+ */
+int
+mrvl_get_qoscfg(const char *key __rte_unused, const char *path,
+               void *extra_args)
+{
+       struct mrvl_qos_cfg **cfg = extra_args;
+       struct rte_cfgfile *file = rte_cfgfile_load(path, 0);
+       uint32_t val;
+       int n, i, ret;
+       const char *entry;
+       char sec_name[32];
+
+       if (file == NULL)
+               rte_exit(EXIT_FAILURE, "Cannot load configuration %s\n", path);
+
+       /* Create configuration. This is never accessed on the fast path,
+        * so we can ignore socket.
+        */
+       *cfg = rte_zmalloc("mrvl_qos_cfg", sizeof(struct mrvl_qos_cfg), 0);
+       if (*cfg == NULL)
+               rte_exit(EXIT_FAILURE, "Cannot allocate configuration %s\n",
+                       path);
+
+       n = rte_cfgfile_num_sections(file, MRVL_TOK_PORT,
+               sizeof(MRVL_TOK_PORT) - 1);
+
+       if (n == 0) {
+               /* This is weird, but not bad. */
+               RTE_LOG(WARNING, PMD, "Empty configuration file?\n");
+               return 0;
+       }
+
+       /* Use the number of ports given as vdev parameters. */
+       for (n = 0; n < mrvl_ports_nb; ++n) {
+               snprintf(sec_name, sizeof(sec_name), "%s %d %s",
+                       MRVL_TOK_PORT, n, MRVL_TOK_DEFAULT);
+
+               /* Skip ports non-existing in configuration. */
+               if (rte_cfgfile_num_sections(file, sec_name,
+                               strlen(sec_name)) <= 0) {
+                       (*cfg)->port[n].use_global_defaults = 1;
+                       (*cfg)->port[n].mapping_priority =
+                               PP2_CLS_QOS_TBL_VLAN_IP_PRI;
+                       continue;
+               }
+
+               entry = rte_cfgfile_get_entry(file, sec_name,
+                               MRVL_TOK_DEFAULT_TC);
+               if (entry) {
+                       if (get_val_securely(entry, &val) < 0 ||
+                               val > USHRT_MAX)
+                               return -1;
+                       (*cfg)->port[n].default_tc = (uint8_t)val;
+               } else {
+                       RTE_LOG(ERR, PMD,
+                               "Default Traffic Class required in custom configuration!\n");
+                       return -1;
+               }
+
+               entry = rte_cfgfile_get_entry(file, sec_name,
+                               MRVL_TOK_MAPPING_PRIORITY);
+               if (entry) {
+                       if (!strncmp(entry, MRVL_TOK_VLAN_IP,
+                               sizeof(MRVL_TOK_VLAN_IP)))
+                               (*cfg)->port[n].mapping_priority =
+                                       PP2_CLS_QOS_TBL_VLAN_IP_PRI;
+                       else if (!strncmp(entry, MRVL_TOK_IP_VLAN,
+                               sizeof(MRVL_TOK_IP_VLAN)))
+                               (*cfg)->port[n].mapping_priority =
+                                       PP2_CLS_QOS_TBL_IP_VLAN_PRI;
+                       else if (!strncmp(entry, MRVL_TOK_IP,
+                               sizeof(MRVL_TOK_IP)))
+                               (*cfg)->port[n].mapping_priority =
+                                       PP2_CLS_QOS_TBL_IP_PRI;
+                       else if (!strncmp(entry, MRVL_TOK_VLAN,
+                               sizeof(MRVL_TOK_VLAN)))
+                               (*cfg)->port[n].mapping_priority =
+                                       PP2_CLS_QOS_TBL_VLAN_PRI;
+                       else
+                               rte_exit(EXIT_FAILURE,
+                                       "Error in parsing %s value (%s)!\n",
+                                       MRVL_TOK_MAPPING_PRIORITY, entry);
+               } else {
+                       (*cfg)->port[n].mapping_priority =
+                               PP2_CLS_QOS_TBL_VLAN_IP_PRI;
+               }
+
+               for (i = 0; i < MRVL_PP2_RXQ_MAX; ++i) {
+                       ret = get_outq_cfg(file, n, i, *cfg);
+                       if (ret < 0)
+                               rte_exit(EXIT_FAILURE,
+                                       "Error %d parsing port %d outq %d!\n",
+                                       ret, n, i);
+               }
+
+               for (i = 0; i < MRVL_PP2_TC_MAX; ++i) {
+                       ret = parse_tc_cfg(file, n, i, *cfg);
+                       if (ret < 0)
+                               rte_exit(EXIT_FAILURE,
+                                       "Error %d parsing port %d tc %d!\n",
+                                       ret, n, i);
+               }
+       }
+
+       return 0;
+}
+
+/**
+ * Setup Traffic Class.
+ *
+ * Fill in TC parameters in single MUSDK TC config entry.
+ * @param param TC parameters entry.
+ * @param inqs Number of MUSDK in-queues in this TC.
+ * @param bpool Bpool for this TC.
+ * @returns 0 in case of success, exits otherwise.
+ */
+static int
+setup_tc(struct pp2_ppio_tc_params *param, uint8_t inqs,
+       struct pp2_bpool *bpool)
+{
+       struct pp2_ppio_inq_params *inq_params;
+
+       param->pkt_offset = MRVL_PKT_OFFS;
+       param->pools[0] = bpool;
+
+       inq_params = rte_zmalloc_socket("inq_params",
+               inqs * sizeof(*inq_params),
+               0, rte_socket_id());
+       if (!inq_params)
+               return -ENOMEM;
+
+       param->num_in_qs = inqs;
+
+       /* Release old config if necessary. */
+       if (param->inqs_params)
+               rte_free(param->inqs_params);
+
+       param->inqs_params = inq_params;
+
+       return 0;
+}
+
+/**
+ * Configure RX Queues in a given port.
+ *
+ * Sets up RX queues, their Traffic Classes and DPDK rxq->(TC,inq) mapping.
+ *
+ * @param priv Port's private data
+ * @param portid DPDK port ID
+ * @param max_queues Maximum number of queues to configure.
+ * @returns 0 in case of success, negative value otherwise.
+ */
+int
+mrvl_configure_rxqs(struct mrvl_priv *priv, uint8_t portid,
+       uint16_t max_queues)
+{
+       size_t i, tc;
+
+       if (mrvl_qos_cfg == NULL ||
+               mrvl_qos_cfg->port[portid].use_global_defaults) {
+               /* No port configuration, use default: 1 TC, no QoS. */
+               priv->ppio_params.inqs_params.num_tcs = 1;
+               setup_tc(&priv->ppio_params.inqs_params.tcs_params[0],
+                       max_queues, priv->bpool);
+
+               /* Direct mapping of queues i.e. 0->0, 1->1 etc. */
+               for (i = 0; i < max_queues; ++i) {
+                       priv->rxq_map[i].tc = 0;
+                       priv->rxq_map[i].inq = i;
+               }
+               return 0;
+       }
+
+       /* We need only a subset of configuration. */
+       struct port_cfg *port_cfg = &mrvl_qos_cfg->port[portid];
+
+       priv->qos_tbl_params.type = port_cfg->mapping_priority;
+
+       /*
+        * We need to reverse mapping, from tc->pcp (better from usability
+        * point of view) to pcp->tc (configurable in MUSDK).
+        * First, set all map elements to "default".
+        */
+       for (i = 0; i < RTE_DIM(priv->qos_tbl_params.pcp_cos_map); ++i)
+               priv->qos_tbl_params.pcp_cos_map[i].tc = port_cfg->default_tc;
+
+       /* Then, fill in all known values. */
+       for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
+               if (port_cfg->tc[tc].pcps > RTE_DIM(port_cfg->tc[0].pcp)) {
+                       /* Better safe than sorry. */
+                       RTE_LOG(ERR, PMD,
+                               "Too many PCPs configured in TC %zu!\n", tc);
+                       return -1;
+               }
+               for (i = 0; i < port_cfg->tc[tc].pcps; ++i) {
+                       priv->qos_tbl_params.pcp_cos_map[
+                         port_cfg->tc[tc].pcp[i]].tc = tc;
+               }
+       }
+
+       /*
+        * The same logic goes with DSCP.
+        * First, set all map elements to "default".
+        */
+       for (i = 0; i < RTE_DIM(priv->qos_tbl_params.dscp_cos_map); ++i)
+               priv->qos_tbl_params.dscp_cos_map[i].tc =
+                       port_cfg->default_tc;
+
+       /* Fill in all known values. */
+       for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
+               if (port_cfg->tc[tc].dscps > RTE_DIM(port_cfg->tc[0].dscp)) {
+                       /* Better safe than sorry. */
+                       RTE_LOG(ERR, PMD,
+                               "Too many DSCPs configured in TC %zu!\n", tc);
+                       return -1;
+               }
+               for (i = 0; i < port_cfg->tc[tc].dscps; ++i) {
+                       priv->qos_tbl_params.dscp_cos_map[
+                         port_cfg->tc[tc].dscp[i]].tc = tc;
+               }
+       }
+
+       /*
+        * Surprisingly, similar logic goes with queue mapping.
+        * We need only to store qid->tc mapping,
+        * to know TC when queue is read.
+        */
+       for (i = 0; i < RTE_DIM(priv->rxq_map); ++i)
+               priv->rxq_map[i].tc = MRVL_UNKNOWN_TC;
+
+       /* Set up DPDKq->(TC,inq) mapping. */
+       for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
+               if (port_cfg->tc[tc].inqs > RTE_DIM(port_cfg->tc[0].inq)) {
+                       /* Overflow. */
+                       RTE_LOG(ERR, PMD,
+                               "Too many RX queues configured per TC %zu!\n",
+                               tc);
+                       return -1;
+               }
+               for (i = 0; i < port_cfg->tc[tc].inqs; ++i) {
+                       uint8_t idx = port_cfg->tc[tc].inq[i];
+
+                       if (idx > RTE_DIM(priv->rxq_map)) {
+                               RTE_LOG(ERR, PMD, "Bad queue index %d!\n", idx);
+                               return -1;
+                       }
+
+                       priv->rxq_map[idx].tc = tc;
+                       priv->rxq_map[idx].inq = i;
+               }
+       }
+
+       /*
+        * Set up TC configuration. TCs need to be sequenced: 0, 1, 2
+        * with no gaps. Empty TC means end of processing.
+        */
+       for (i = 0; i < MRVL_PP2_TC_MAX; ++i) {
+               if (port_cfg->tc[i].inqs == 0)
+                       break;
+               setup_tc(&priv->ppio_params.inqs_params.tcs_params[i],
+                               port_cfg->tc[i].inqs,
+                               priv->bpool);
+       }
+
+       priv->ppio_params.inqs_params.num_tcs = i;
+
+       return 0;
+}
+
+/**
+ * Start QoS mapping.
+ *
+ * Finalize QoS table configuration and initialize it in SDK. It can be done
+ * only after port is started, so we have a valid ppio reference.
+ *
+ * @param priv Port's private (configuration) data.
+ * @returns 0 in case of success, exits otherwise.
+ */
+int
+mrvl_start_qos_mapping(struct mrvl_priv *priv)
+{
+       size_t i;
+
+       if (priv->ppio == NULL) {
+               RTE_LOG(ERR, PMD, "ppio must not be NULL here!\n");
+               return -1;
+       }
+
+       for (i = 0; i < RTE_DIM(priv->qos_tbl_params.pcp_cos_map); ++i)
+               priv->qos_tbl_params.pcp_cos_map[i].ppio = priv->ppio;
+
+       for (i = 0; i < RTE_DIM(priv->qos_tbl_params.dscp_cos_map); ++i)
+               priv->qos_tbl_params.dscp_cos_map[i].ppio = priv->ppio;
+
+       /* Initialize Classifier QoS table. */
+
+       return pp2_cls_qos_tbl_init(&priv->qos_tbl_params, &priv->qos_tbl);
+}
diff --git a/drivers/net/mrvl/mrvl_qos.h b/drivers/net/mrvl/mrvl_qos.h
new file mode 100644 (file)
index 0000000..0fcc85c
--- /dev/null
@@ -0,0 +1,112 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2017 Semihalf. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Semihalf nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   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
+ *   OWNER 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.
+ */
+
+#ifndef _MRVL_QOS_H_
+#define _MRVL_QOS_H_
+
+#include <rte_common.h>
+#include <rte_config.h>
+
+#include "mrvl_ethdev.h"
+
+/** Code Points per Traffic Class. Equals max(DSCP, PCP). */
+#define MRVL_CP_PER_TC (64)
+
+/** Value used as "unknown". */
+#define MRVL_UNKNOWN_TC (0xFF)
+
+/* QoS config. */
+struct mrvl_qos_cfg {
+       struct port_cfg {
+               struct {
+                       uint8_t inq[MRVL_PP2_RXQ_MAX];
+                       uint8_t dscp[MRVL_CP_PER_TC];
+                       uint8_t pcp[MRVL_CP_PER_TC];
+                       uint8_t inqs;
+                       uint8_t dscps;
+                       uint8_t pcps;
+               } tc[MRVL_PP2_TC_MAX];
+               struct {
+                       uint8_t weight;
+               } outq[MRVL_PP2_RXQ_MAX];
+               enum pp2_cls_qos_tbl_type mapping_priority;
+               uint16_t inqs;
+               uint16_t outqs;
+               uint8_t default_tc;
+               uint8_t use_global_defaults;
+       } port[RTE_MAX_ETHPORTS];
+};
+
+/** Global QoS configuration. */
+extern struct mrvl_qos_cfg *mrvl_qos_cfg;
+
+/**
+ * Parse QoS configuration - rte_kvargs_process handler.
+ *
+ * Opens configuration file and parses its content.
+ *
+ * @param key Unused.
+ * @param path Path to config file.
+ * @param extra_args Pointer to configuration structure.
+ * @returns 0 in case of success, exits otherwise.
+ */
+int
+mrvl_get_qoscfg(const char *key __rte_unused, const char *path,
+               void *extra_args);
+
+/**
+ * Configure RX Queues in a given port.
+ *
+ * Sets up RX queues, their Traffic Classes and DPDK rxq->(TC,inq) mapping.
+ *
+ * @param priv Port's private data
+ * @param portid DPDK port ID
+ * @param max_queues Maximum number of queues to configure.
+ * @returns 0 in case of success, negative value otherwise.
+ */
+int
+mrvl_configure_rxqs(struct mrvl_priv *priv, uint8_t portid,
+                   uint16_t max_queues);
+
+/**
+ * Start QoS mapping.
+ *
+ * Finalize QoS table configuration and initialize it in SDK. It can be done
+ * only after port is started, so we have a valid ppio reference.
+ *
+ * @param priv Port's private (configuration) data.
+ * @returns 0 in case of success, exits otherwise.
+ */
+int
+mrvl_start_qos_mapping(struct mrvl_priv *priv);
+
+#endif /* _MRVL_QOS_H_ */
diff --git a/drivers/net/mrvl/rte_pmd_mrvl_version.map b/drivers/net/mrvl/rte_pmd_mrvl_version.map
new file mode 100644 (file)
index 0000000..a753031
--- /dev/null
@@ -0,0 +1,3 @@
+DPDK_17.11 {
+       local: *;
+};
index fdbe3c7..cee21ea 100644 (file)
@@ -137,6 +137,7 @@ endif
 _LDLIBS-$(CONFIG_RTE_LIBRTE_LIO_PMD)        += -lrte_pmd_lio
 _LDLIBS-$(CONFIG_RTE_LIBRTE_MLX4_PMD)       += -lrte_pmd_mlx4 -libverbs
 _LDLIBS-$(CONFIG_RTE_LIBRTE_MLX5_PMD)       += -lrte_pmd_mlx5 -libverbs -lmlx5
+_LDLIBS-$(CONFIG_RTE_LIBRTE_MRVL_PMD)       += -lrte_pmd_mrvl -L$(LIBMUSDK_PATH)/lib -lmusdk
 _LDLIBS-$(CONFIG_RTE_LIBRTE_NFP_PMD)        += -lrte_pmd_nfp
 _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_NULL)       += -lrte_pmd_null
 _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_PCAP)       += -lrte_pmd_pcap -lpcap