11 files changed, 911 insertions, 8 deletions

diff --git a/src/plugins/dev_octeon/CMakeLists.txt b/src/plugins/dev_octeon/CMakeLists.txt
index e8abf1a3389..c6271ecdfba 100644
--- a/src/plugins/dev_octeon/CMakeLists.txt
+++ b/src/plugins/dev_octeon/CMakeLists.txt
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright(c) 2022 Cisco Systems, Inc.
 
-if (NOT VPP_PLATFORM_NAME STREQUAL "octeon10")
+if (NOT VPP_PLATFORM_NAME STREQUAL "octeon10" AND NOT VPP_PLATFORM_NAME STREQUAL "octeon9")
   return()
 endif()
 
@@ -21,6 +21,10 @@ endif()
 
 include_directories (${OCTEON_ROC_DIR}/)
 
+if (VPP_PLATFORM_NAME STREQUAL "octeon9")
+   add_compile_definitions(PLATFORM_OCTEON9)
+endif()
+
 add_vpp_plugin(dev_octeon
   SOURCES
   init.c
@@ -31,6 +35,7 @@ add_vpp_plugin(dev_octeon
   rx_node.c
   tx_node.c
   flow.c
+  counter.c
 
   MULTIARCH_SOURCES
   rx_node.c
diff --git a/src/plugins/dev_octeon/counter.c b/src/plugins/dev_octeon/counter.c
new file mode 100644
index 00000000000..6f57c1ee649
--- /dev/null
+++ b/src/plugins/dev_octeon/counter.c
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2024 Marvell.
+ * SPDX-License-Identifier: Apache-2.0
+ * https://spdx.org/licenses/Apache-2.0.html
+ */
+
+#include <vnet/vnet.h>
+#include <vnet/dev/dev.h>
+#include <vnet/dev/counters.h>
+#include <dev_octeon/octeon.h>
+#include <dev_octeon/common.h>
+
+VLIB_REGISTER_LOG_CLASS (oct_log, static) = {
+  .class_name = "oct",
+  .subclass_name = "counters",
+};
+
+typedef enum
+{
+  OCT_PORT_CTR_RX_BYTES,
+  OCT_PORT_CTR_TX_BYTES,
+  OCT_PORT_CTR_RX_PACKETS,
+  OCT_PORT_CTR_TX_PACKETS,
+  OCT_PORT_CTR_RX_DROPS,
+  OCT_PORT_CTR_TX_DROPS,
+  OCT_PORT_CTR_RX_DROP_BYTES,
+  OCT_PORT_CTR_RX_UCAST,
+  OCT_PORT_CTR_TX_UCAST,
+  OCT_PORT_CTR_RX_MCAST,
+  OCT_PORT_CTR_TX_MCAST,
+  OCT_PORT_CTR_RX_BCAST,
+  OCT_PORT_CTR_TX_BCAST,
+  OCT_PORT_CTR_RX_FCS,
+  OCT_PORT_CTR_RX_ERR,
+  OCT_PORT_CTR_RX_DROP_MCAST,
+  OCT_PORT_CTR_RX_DROP_BCAST,
+  OCT_PORT_CTR_RX_DROP_L3_MCAST,
+  OCT_PORT_CTR_RX_DROP_L3_BCAST,
+} oct_port_counter_id_t;
+
+vnet_dev_counter_t oct_port_counters[] = {
+  VNET_DEV_CTR_RX_BYTES (OCT_PORT_CTR_RX_BYTES),
+  VNET_DEV_CTR_RX_PACKETS (OCT_PORT_CTR_RX_PACKETS),
+  VNET_DEV_CTR_RX_DROPS (OCT_PORT_CTR_RX_DROPS),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_DROP_BYTES, RX, BYTES, "drop bytes"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_UCAST, RX, PACKETS, "unicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_MCAST, RX, PACKETS, "multicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_BCAST, RX, PACKETS, "broadcast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_FCS, RX, PACKETS, "fcs"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_ERR, RX, PACKETS, "error"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_DROP_MCAST, RX, PACKETS,
+		       "drop multicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_DROP_BCAST, RX, PACKETS,
+		       "drop broadcast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_DROP_L3_MCAST, RX, PACKETS,
+		       "drop L3 multicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_RX_DROP_L3_BCAST, RX, PACKETS,
+		       "drop L3 broadcast"),
+
+  VNET_DEV_CTR_TX_BYTES (OCT_PORT_CTR_TX_BYTES),
+  VNET_DEV_CTR_TX_PACKETS (OCT_PORT_CTR_TX_PACKETS),
+  VNET_DEV_CTR_TX_DROPS (OCT_PORT_CTR_TX_DROPS),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_TX_UCAST, TX, PACKETS, "unicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_TX_MCAST, TX, PACKETS, "multicast"),
+  VNET_DEV_CTR_VENDOR (OCT_PORT_CTR_TX_BCAST, TX, PACKETS, "broadcast"),
+};
+
+typedef enum
+{
+  OCT_RXQ_CTR_BYTES,
+  OCT_RXQ_CTR_PKTS,
+  OCT_RXQ_CTR_DROPS,
+  OCT_RXQ_CTR_DROP_BYTES,
+  OCT_RXQ_CTR_ERR,
+} oct_rxq_counter_id_t;
+
+vnet_dev_counter_t oct_rxq_counters[] = {
+  VNET_DEV_CTR_RX_BYTES (OCT_RXQ_CTR_BYTES),
+  VNET_DEV_CTR_RX_PACKETS (OCT_RXQ_CTR_PKTS),
+  VNET_DEV_CTR_RX_DROPS (OCT_RXQ_CTR_DROPS),
+  VNET_DEV_CTR_VENDOR (OCT_RXQ_CTR_DROP_BYTES, RX, BYTES, "drop bytes"),
+  VNET_DEV_CTR_VENDOR (OCT_RXQ_CTR_ERR, RX, PACKETS, "error"),
+};
+
+typedef enum
+{
+  OCT_TXQ_CTR_BYTES,
+  OCT_TXQ_CTR_PKTS,
+  OCT_TXQ_CTR_DROPS,
+  OCT_TXQ_CTR_DROP_BYTES,
+} oct_txq_counter_id_t;
+
+vnet_dev_counter_t oct_txq_counters[] = {
+  VNET_DEV_CTR_TX_BYTES (OCT_TXQ_CTR_BYTES),
+  VNET_DEV_CTR_TX_PACKETS (OCT_TXQ_CTR_PKTS),
+  VNET_DEV_CTR_TX_DROPS (OCT_TXQ_CTR_DROPS),
+  VNET_DEV_CTR_VENDOR (OCT_TXQ_CTR_DROP_BYTES, TX, BYTES, "drop bytes"),
+};
+
+static vnet_dev_rv_t
+oct_roc_err (vnet_dev_t *dev, int rv, char *fmt, ...)
+{
+  u8 *s = 0;
+  va_list va;
+
+  va_start (va, fmt);
+  s = va_format (s, fmt, &va);
+  va_end (va);
+
+  log_err (dev, "%v - ROC error %s (%d)", s, roc_error_msg_get (rv), rv);
+
+  vec_free (s);
+  return VNET_DEV_ERR_INTERNAL;
+}
+
+void
+oct_port_add_counters (vlib_main_t *vm, vnet_dev_port_t *port)
+{
+  vnet_dev_port_add_counters (vm, port, oct_port_counters,
+			      ARRAY_LEN (oct_port_counters));
+
+  foreach_vnet_dev_port_rx_queue (rxq, port)
+    {
+      vnet_dev_rx_queue_add_counters (vm, rxq, oct_rxq_counters,
+				      ARRAY_LEN (oct_rxq_counters));
+    }
+
+  foreach_vnet_dev_port_tx_queue (txq, port)
+    {
+      vnet_dev_tx_queue_add_counters (vm, txq, oct_txq_counters,
+				      ARRAY_LEN (oct_txq_counters));
+    }
+}
+
+vnet_dev_rv_t
+oct_port_get_stats (vlib_main_t *vm, vnet_dev_port_t *port)
+{
+  vnet_dev_t *dev = port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+  struct roc_nix_stats stats;
+
+  if ((rrv = roc_nix_stats_get (nix, &stats)))
+    return oct_roc_err (dev, rrv, "roc_nix_stats_get() failed");
+
+  foreach_vnet_dev_counter (c, port->counter_main)
+    {
+      switch (c->user_data)
+	{
+	case OCT_PORT_CTR_RX_BYTES:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_octs);
+	  break;
+	case OCT_PORT_CTR_TX_BYTES:
+	  vnet_dev_counter_value_update (vm, c, stats.tx_octs);
+	  break;
+	case OCT_PORT_CTR_RX_PACKETS:
+	  vnet_dev_counter_value_update (
+	    vm, c, stats.rx_ucast + stats.rx_bcast + stats.rx_mcast);
+	  break;
+	case OCT_PORT_CTR_TX_PACKETS:
+	  vnet_dev_counter_value_update (
+	    vm, c, stats.tx_ucast + stats.tx_bcast + stats.tx_mcast);
+	  break;
+	case OCT_PORT_CTR_RX_DROPS:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop);
+	  break;
+	case OCT_PORT_CTR_TX_DROPS:
+	  vnet_dev_counter_value_update (vm, c, stats.tx_drop);
+	  break;
+	case OCT_PORT_CTR_RX_DROP_BYTES:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop_octs);
+	  break;
+	case OCT_PORT_CTR_RX_UCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_ucast);
+	  break;
+	case OCT_PORT_CTR_TX_UCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.tx_ucast);
+	  break;
+	case OCT_PORT_CTR_RX_MCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_mcast);
+	  break;
+	case OCT_PORT_CTR_TX_MCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.tx_mcast);
+	  break;
+	case OCT_PORT_CTR_RX_BCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_bcast);
+	  break;
+	case OCT_PORT_CTR_TX_BCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.tx_bcast);
+	  break;
+	case OCT_PORT_CTR_RX_FCS:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_fcs);
+	  break;
+	case OCT_PORT_CTR_RX_ERR:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_err);
+	  break;
+	case OCT_PORT_CTR_RX_DROP_MCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop_mcast);
+	  break;
+	case OCT_PORT_CTR_RX_DROP_BCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop_bcast);
+	  break;
+	case OCT_PORT_CTR_RX_DROP_L3_MCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop_l3_mcast);
+	  break;
+	case OCT_PORT_CTR_RX_DROP_L3_BCAST:
+	  vnet_dev_counter_value_update (vm, c, stats.rx_drop_l3_bcast);
+	  break;
+	default:
+	  ASSERT (0);
+	}
+    }
+
+  return VNET_DEV_OK;
+}
+
+vnet_dev_rv_t
+oct_rxq_get_stats (vlib_main_t *vm, vnet_dev_port_t *port,
+		   vnet_dev_rx_queue_t *rxq)
+{
+  oct_rxq_t *crq = vnet_dev_get_rx_queue_data (rxq);
+  struct roc_nix_stats_queue qstats;
+  vnet_dev_t *dev = port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+
+  if ((rrv = roc_nix_stats_queue_get (nix, crq->rq.qid, 1, &qstats)))
+    return oct_roc_err (dev, rrv, "roc_nix_stats_queue_get() failed");
+
+  foreach_vnet_dev_counter (c, rxq->counter_main)
+    {
+      switch (c->user_data)
+	{
+	case OCT_RXQ_CTR_BYTES:
+	  vnet_dev_counter_value_update (vm, c, qstats.rx_octs);
+	  break;
+	case OCT_RXQ_CTR_PKTS:
+	  vnet_dev_counter_value_update (vm, c, qstats.rx_pkts);
+	  break;
+	case OCT_RXQ_CTR_DROPS:
+	  vnet_dev_counter_value_update (vm, c, qstats.rx_drop_pkts);
+	  break;
+	case OCT_RXQ_CTR_DROP_BYTES:
+	  vnet_dev_counter_value_update (vm, c, qstats.rx_drop_octs);
+	  break;
+	case OCT_RXQ_CTR_ERR:
+	  vnet_dev_counter_value_update (vm, c, qstats.rx_error_pkts);
+	  break;
+	default:
+	  ASSERT (0);
+	}
+    }
+
+  return VNET_DEV_OK;
+}
+
+vnet_dev_rv_t
+oct_txq_get_stats (vlib_main_t *vm, vnet_dev_port_t *port,
+		   vnet_dev_tx_queue_t *txq)
+{
+  oct_txq_t *ctq = vnet_dev_get_tx_queue_data (txq);
+  struct roc_nix_stats_queue qstats;
+  vnet_dev_t *dev = port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+
+  if ((rrv = roc_nix_stats_queue_get (nix, ctq->sq.qid, 0, &qstats)))
+    return oct_roc_err (dev, rrv, "roc_nix_stats_queue_get() failed");
+
+  foreach_vnet_dev_counter (c, txq->counter_main)
+    {
+      switch (c->user_data)
+	{
+	case OCT_TXQ_CTR_BYTES:
+	  vnet_dev_counter_value_update (vm, c, qstats.tx_octs);
+	  break;
+	case OCT_TXQ_CTR_PKTS:
+	  vnet_dev_counter_value_update (vm, c, qstats.tx_pkts);
+	  break;
+	case OCT_TXQ_CTR_DROPS:
+	  vnet_dev_counter_value_update (vm, c, qstats.tx_drop_pkts);
+	  break;
+	case OCT_TXQ_CTR_DROP_BYTES:
+	  vnet_dev_counter_value_update (vm, c, qstats.tx_drop_octs);
+	  break;
+	default:
+	  ASSERT (0);
+	}
+    }
+
+  return VNET_DEV_OK;
+}
+
+void
+oct_port_clear_counters (vlib_main_t *vm, vnet_dev_port_t *port)
+{
+  vnet_dev_t *dev = port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+
+  if ((rrv = roc_nix_stats_reset (nix)))
+    oct_roc_err (dev, rrv, "roc_nix_stats_reset() failed");
+}
+
+void
+oct_rxq_clear_counters (vlib_main_t *vm, vnet_dev_rx_queue_t *rxq)
+{
+  oct_rxq_t *crq = vnet_dev_get_rx_queue_data (rxq);
+  vnet_dev_t *dev = rxq->port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+
+  if ((rrv = roc_nix_stats_queue_reset (nix, crq->rq.qid, 1)))
+    oct_roc_err (dev, rrv,
+		 "roc_nix_stats_queue_reset() failed for rx queue %u",
+		 rxq->queue_id);
+}
+
+void
+oct_txq_clear_counters (vlib_main_t *vm, vnet_dev_tx_queue_t *txq)
+{
+  oct_txq_t *ctq = vnet_dev_get_tx_queue_data (txq);
+  vnet_dev_t *dev = txq->port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  int rrv;
+
+  if ((rrv = roc_nix_stats_queue_reset (nix, ctq->sq.qid, 0)))
+    oct_roc_err (dev, rrv,
+		 "roc_nix_stats_queue_reset() failed for tx queue %u",
+		 txq->queue_id);
+}
diff --git a/src/plugins/dev_octeon/flow.c b/src/plugins/dev_octeon/flow.c
index 1c367a036ab..35aabde76a7 100644
--- a/src/plugins/dev_octeon/flow.c
+++ b/src/plugins/dev_octeon/flow.c
@@ -46,6 +46,8 @@ VLIB_REGISTER_LOG_CLASS (oct_log, static) = {
    (f->type == VNET_FLOW_TYPE_IP4_GTPC) ||                                    \
    (f->type == VNET_FLOW_TYPE_IP4_GTPU))
 
+#define FLOW_IS_GENERIC_TYPE(f) (f->type == VNET_FLOW_TYPE_GENERIC)
+
 #define OCT_FLOW_UNSUPPORTED_ACTIONS(f)                                       \
   ((f->actions == VNET_FLOW_ACTION_BUFFER_ADVANCE) ||                         \
    (f->actions == VNET_FLOW_ACTION_REDIRECT_TO_NODE))
@@ -71,6 +73,9 @@ VLIB_REGISTER_LOG_CLASS (oct_log, static) = {
   _ (62, FLOW_KEY_TYPE_L3_DST, "l3-dst-only")                                 \
   _ (63, FLOW_KEY_TYPE_L3_SRC, "l3-src-only")
 
+#define GTPU_PORT  2152
+#define VXLAN_PORT 4789
+
 typedef struct
 {
   u16 src_port;
@@ -87,6 +92,27 @@ typedef struct
   u32 teid;
 } gtpu_header_t;
 
+typedef struct
+{
+  u8 layer;
+  u16 nxt_proto;
+  vnet_dev_port_t *port;
+  struct roc_npc_item_info *items;
+  struct
+  {
+    u8 *spec;
+    u8 *mask;
+    u16 off;
+  } oct_drv;
+  struct
+  {
+    u8 *spec;
+    u8 *mask;
+    u16 off;
+    u16 len;
+  } generic;
+} oct_flow_parse_state;
+
 static void
 oct_flow_convert_rss_types (u64 *key, u64 rss_types)
 {
@@ -183,6 +209,320 @@ oct_flow_rule_create (vnet_dev_port_t *port, struct roc_npc_action *actions,
   return VNET_DEV_OK;
 }
 
+static int
+oct_parse_l2 (oct_flow_parse_state *pst)
+{
+  struct roc_npc_flow_item_eth *eth_spec =
+    (struct roc_npc_flow_item_eth *) &pst->oct_drv.spec[pst->oct_drv.off];
+  struct roc_npc_flow_item_eth *eth_mask =
+    (struct roc_npc_flow_item_eth *) &pst->oct_drv.mask[pst->oct_drv.off];
+  ethernet_header_t *eth_hdr_mask =
+    (ethernet_header_t *) &pst->generic.mask[pst->generic.off];
+  ethernet_header_t *eth_hdr =
+    (ethernet_header_t *) &pst->generic.spec[pst->generic.off];
+  u16 tpid, etype;
+
+  tpid = etype = clib_net_to_host_u16 (eth_hdr->type);
+  clib_memcpy_fast (eth_spec, eth_hdr, sizeof (ethernet_header_t));
+  clib_memcpy_fast (eth_mask, eth_hdr_mask, sizeof (ethernet_header_t));
+  eth_spec->has_vlan = 0;
+
+  pst->items[pst->layer].spec = (void *) eth_spec;
+  pst->items[pst->layer].mask = (void *) eth_mask;
+  pst->items[pst->layer].size = sizeof (ethernet_header_t);
+  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_ETH;
+  pst->generic.off += sizeof (ethernet_header_t);
+  pst->oct_drv.off += sizeof (struct roc_npc_flow_item_eth);
+  pst->layer++;
+
+  /* Parse VLAN Tags if any */
+  struct roc_npc_flow_item_vlan *vlan_spec =
+    (struct roc_npc_flow_item_vlan *) &pst->oct_drv.spec[pst->oct_drv.off];
+  struct roc_npc_flow_item_vlan *vlan_mask =
+    (struct roc_npc_flow_item_vlan *) &pst->oct_drv.mask[pst->oct_drv.off];
+  ethernet_vlan_header_t *vlan_hdr, *vlan_hdr_mask;
+  u8 vlan_cnt = 0;
+
+  while (tpid == ETHERNET_TYPE_DOT1AD || tpid == ETHERNET_TYPE_VLAN)
+    {
+      if (pst->generic.off >= pst->generic.len)
+	break;
+
+      vlan_hdr =
+	(ethernet_vlan_header_t *) &pst->generic.spec[pst->generic.off];
+      vlan_hdr_mask =
+	(ethernet_vlan_header_t *) &pst->generic.mask[pst->generic.off];
+      tpid = etype = clib_net_to_host_u16 (vlan_hdr->type);
+      clib_memcpy (&vlan_spec[vlan_cnt], vlan_hdr,
+		   sizeof (ethernet_vlan_header_t));
+      clib_memcpy (&vlan_mask[vlan_cnt], vlan_hdr_mask,
+		   sizeof (ethernet_vlan_header_t));
+      pst->items[pst->layer].spec = (void *) &vlan_spec[vlan_cnt];
+      pst->items[pst->layer].mask = (void *) &vlan_mask[vlan_cnt];
+      pst->items[pst->layer].size = sizeof (ethernet_vlan_header_t);
+      pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_VLAN;
+      pst->generic.off += sizeof (ethernet_vlan_header_t);
+      pst->oct_drv.off += sizeof (struct roc_npc_flow_item_vlan);
+      pst->layer++;
+      vlan_cnt++;
+    }
+
+  /* Inner most vlan tag */
+  if (vlan_cnt)
+    vlan_spec[vlan_cnt - 1].has_more_vlan = 0;
+
+  pst->nxt_proto = etype;
+  return 0;
+}
+
+static int
+oct_parse_l3 (oct_flow_parse_state *pst)
+{
+
+  if (pst->generic.off >= pst->generic.len || pst->nxt_proto == 0)
+    return 0;
+
+  if (pst->nxt_proto == ETHERNET_TYPE_MPLS)
+    {
+      int label_stack_bottom = 0;
+      do
+	{
+
+	  u8 *mpls_spec = &pst->generic.spec[pst->generic.off];
+	  u8 *mpls_mask = &pst->generic.mask[pst->generic.off];
+
+	  label_stack_bottom = mpls_spec[2] & 1;
+	  pst->items[pst->layer].spec = (void *) mpls_spec;
+	  pst->items[pst->layer].mask = (void *) mpls_mask;
+	  pst->items[pst->layer].size = sizeof (u32);
+	  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_MPLS;
+	  pst->generic.off += sizeof (u32);
+	  pst->layer++;
+	}
+      while (label_stack_bottom);
+
+      pst->nxt_proto = 0;
+      return 0;
+    }
+  else if (pst->nxt_proto == ETHERNET_TYPE_IP4)
+    {
+      ip4_header_t *ip4_spec =
+	(ip4_header_t *) &pst->generic.spec[pst->generic.off];
+      ip4_header_t *ip4_mask =
+	(ip4_header_t *) &pst->generic.mask[pst->generic.off];
+      pst->items[pst->layer].spec = (void *) ip4_spec;
+      pst->items[pst->layer].mask = (void *) ip4_mask;
+      pst->items[pst->layer].size = sizeof (ip4_header_t);
+      pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_IPV4;
+      pst->generic.off += sizeof (ip4_header_t);
+      pst->layer++;
+      pst->nxt_proto = ip4_spec->protocol;
+    }
+  else if (pst->nxt_proto == ETHERNET_TYPE_IP6)
+    {
+      struct roc_npc_flow_item_ipv6 *ip6_spec =
+	(struct roc_npc_flow_item_ipv6 *) &pst->oct_drv.spec[pst->oct_drv.off];
+      struct roc_npc_flow_item_ipv6 *ip6_mask =
+	(struct roc_npc_flow_item_ipv6 *) &pst->oct_drv.mask[pst->oct_drv.off];
+      ip6_header_t *ip6_hdr_mask =
+	(ip6_header_t *) &pst->generic.mask[pst->generic.off];
+      ip6_header_t *ip6_hdr =
+	(ip6_header_t *) &pst->generic.spec[pst->generic.off];
+      u8 nxt_hdr = ip6_hdr->protocol;
+
+      clib_memcpy (ip6_spec, ip6_hdr, sizeof (ip6_header_t));
+      clib_memcpy (ip6_mask, ip6_hdr_mask, sizeof (ip6_header_t));
+      pst->items[pst->layer].spec = (void *) ip6_spec;
+      pst->items[pst->layer].mask = (void *) ip6_mask;
+      pst->items[pst->layer].size = sizeof (ip6_header_t);
+      pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_IPV6;
+      pst->generic.off += sizeof (ip6_header_t);
+      pst->oct_drv.off += sizeof (struct roc_npc_flow_item_ipv6);
+      pst->layer++;
+
+      while (nxt_hdr == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS ||
+	     nxt_hdr == IP_PROTOCOL_IP6_DESTINATION_OPTIONS ||
+	     nxt_hdr == IP_PROTOCOL_IPV6_ROUTE)
+	{
+	  if (pst->generic.off >= pst->generic.len)
+	    return 0;
+
+	  ip6_ext_header_t *ip6_ext_spec =
+	    (ip6_ext_header_t *) &pst->generic.spec[pst->generic.off];
+	  ip6_ext_header_t *ip6_ext_mask =
+	    (ip6_ext_header_t *) &pst->generic.mask[pst->generic.off];
+	  nxt_hdr = ip6_ext_spec->next_hdr;
+
+	  pst->items[pst->layer].spec = (void *) ip6_ext_spec;
+	  pst->items[pst->layer].mask = (void *) ip6_ext_mask;
+	  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_IPV6_EXT;
+	  pst->generic.off += ip6_ext_header_len (ip6_ext_spec);
+	  pst->layer++;
+	}
+
+      if (pst->generic.off >= pst->generic.len)
+	return 0;
+
+      if (nxt_hdr == IP_PROTOCOL_IPV6_FRAGMENTATION)
+	{
+	  ip6_frag_hdr_t *ip6_ext_frag_spec =
+	    (ip6_frag_hdr_t *) &pst->generic.spec[pst->generic.off];
+	  ip6_frag_hdr_t *ip6_ext_frag_mask =
+	    (ip6_frag_hdr_t *) &pst->generic.mask[pst->generic.off];
+
+	  pst->items[pst->layer].spec = (void *) ip6_ext_frag_spec;
+	  pst->items[pst->layer].mask = (void *) ip6_ext_frag_mask;
+	  pst->items[pst->layer].size = sizeof (ip6_frag_hdr_t);
+	  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_IPV6_FRAG_EXT;
+	  pst->generic.off += sizeof (ip6_frag_hdr_t);
+	  pst->layer++;
+	}
+
+      pst->nxt_proto = nxt_hdr;
+    }
+  /* Unsupported L3. */
+  else
+    return -1;
+
+  return 0;
+}
+
+static int
+oct_parse_l4 (oct_flow_parse_state *pst)
+{
+
+  if (pst->generic.off >= pst->generic.len || pst->nxt_proto == 0)
+    return 0;
+
+#define _(protocol_t, protocol_value, ltype)                                  \
+  if (pst->nxt_proto == protocol_value)                                       \
+                                                                              \
+    {                                                                         \
+                                                                              \
+      protocol_t *spec = (protocol_t *) &pst->generic.spec[pst->generic.off]; \
+      protocol_t *mask = (protocol_t *) &pst->generic.mask[pst->generic.off]; \
+      pst->items[pst->layer].spec = spec;                                     \
+      pst->items[pst->layer].mask = mask;                                     \
+                                                                              \
+      pst->items[pst->layer].size = sizeof (protocol_t);                      \
+                                                                              \
+      pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_##ltype;                \
+      pst->generic.off += sizeof (protocol_t);                                \
+      pst->layer++;                                                           \
+      return 0;                                                               \
+    }
+
+  _ (esp_header_t, IP_PROTOCOL_IPSEC_ESP, ESP)
+  _ (udp_header_t, IP_PROTOCOL_UDP, UDP)
+  _ (tcp_header_t, IP_PROTOCOL_TCP, TCP)
+  _ (sctp_header_t, IP_PROTOCOL_SCTP, SCTP)
+  _ (icmp46_header_t, IP_PROTOCOL_ICMP, ICMP)
+  _ (icmp46_header_t, IP_PROTOCOL_ICMP6, ICMP)
+  _ (igmp_header_t, IP_PROTOCOL_IGMP, IGMP)
+  _ (gre_header_t, IP_PROTOCOL_GRE, GRE)
+
+  /* Unsupported L4. */
+  return -1;
+}
+
+static int
+oct_parse_tunnel (oct_flow_parse_state *pst)
+{
+  if (pst->generic.off >= pst->generic.len)
+    return 0;
+
+  if (pst->items[pst->layer - 1].type == ROC_NPC_ITEM_TYPE_GRE)
+    {
+      gre_header_t *gre_hdr = (gre_header_t *) pst->items[pst->layer - 1].spec;
+      pst->nxt_proto = clib_net_to_host_u16 (gre_hdr->protocol);
+      goto parse_l3;
+    }
+
+  else if (pst->items[pst->layer - 1].type == ROC_NPC_ITEM_TYPE_UDP)
+    {
+      udp_header_t *udp_h = (udp_header_t *) pst->items[pst->layer - 1].spec;
+      u16 dport = clib_net_to_host_u16 (udp_h->dst_port);
+
+      if (dport == GTPU_PORT)
+	{
+	  gtpu_header_t *gtpu_spec =
+	    (gtpu_header_t *) &pst->generic.spec[pst->generic.off];
+	  gtpu_header_t *gtpu_mask =
+	    (gtpu_header_t *) &pst->generic.mask[pst->generic.off];
+	  pst->items[pst->layer].spec = (void *) gtpu_spec;
+	  pst->items[pst->layer].mask = (void *) gtpu_mask;
+	  pst->items[pst->layer].size = sizeof (gtpu_header_t);
+	  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_GTPU;
+	  pst->generic.off += sizeof (gtpu_header_t);
+	  pst->layer++;
+	  pst->nxt_proto = 0;
+	  return 0;
+	}
+      else if (dport == VXLAN_PORT)
+	{
+	  vxlan_header_t *vxlan_spec =
+	    (vxlan_header_t *) &pst->generic.spec[pst->generic.off];
+	  vxlan_header_t *vxlan_mask =
+	    (vxlan_header_t *) &pst->generic.spec[pst->generic.off];
+	  pst->items[pst->layer].spec = (void *) vxlan_spec;
+	  pst->items[pst->layer].mask = (void *) vxlan_mask;
+	  pst->items[pst->layer].size = sizeof (vxlan_header_t);
+	  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_VXLAN;
+	  pst->generic.off += sizeof (vxlan_header_t);
+	  pst->layer++;
+	  pst->nxt_proto = 0;
+	  goto parse_l2;
+	}
+    }
+  /* No supported Tunnel detected. */
+  else
+    {
+      log_err (pst->port->dev,
+	       "Partially parsed till offset %u, not able to parse further",
+	       pst->generic.off);
+      return 0;
+    }
+parse_l2:
+  if (oct_parse_l2 (pst))
+    return -1;
+parse_l3:
+  if (oct_parse_l3 (pst))
+    return -1;
+
+  return oct_parse_l4 (pst);
+}
+
+static vnet_dev_rv_t
+oct_flow_generic_pattern_parse (oct_flow_parse_state *pst)
+{
+
+  if (oct_parse_l2 (pst))
+    goto err;
+
+  if (oct_parse_l3 (pst))
+    goto err;
+
+  if (oct_parse_l4 (pst))
+    goto err;
+
+  if (oct_parse_tunnel (pst))
+    goto err;
+
+  if (pst->generic.off < pst->generic.len)
+    {
+      log_err (pst->port->dev,
+	       "Partially parsed till offset %u, not able to parse further",
+	       pst->generic.off);
+      goto err;
+    }
+
+  pst->items[pst->layer].type = ROC_NPC_ITEM_TYPE_END;
+  return VNET_DEV_OK;
+
+err:
+  return VNET_DEV_ERR_NOT_SUPPORTED;
+}
+
 static vnet_dev_rv_t
 oct_flow_add (vlib_main_t *vm, vnet_dev_port_t *port, vnet_flow_t *flow,
 	      uword *private_data)
@@ -196,6 +536,7 @@ oct_flow_add (vlib_main_t *vm, vnet_dev_port_t *port, vnet_flow_t *flow,
   struct roc_npc_action_queue conf = {};
   struct roc_npc_action_mark mark = {};
   struct roc_npc *npc = &oct_port->npc;
+  u8 *flow_spec = 0, *flow_mask = 0;
   vnet_dev_rv_t rv = VNET_DEV_OK;
   int layer = 0, index = 0;
   u16 *queues = NULL;
@@ -203,6 +544,45 @@ oct_flow_add (vlib_main_t *vm, vnet_dev_port_t *port, vnet_flow_t *flow,
   u8 proto = 0;
   u16 action = 0;
 
+  if (FLOW_IS_GENERIC_TYPE (flow))
+    {
+      u8 drv_item_spec[1024] = { 0 }, drv_item_mask[1024] = { 0 };
+      unformat_input_t input;
+      int rc;
+
+      unformat_init_string (
+	&input, (const char *) flow->generic.pattern.spec,
+	strlen ((const char *) flow->generic.pattern.spec));
+      unformat_user (&input, unformat_hex_string, &flow_spec);
+      unformat_free (&input);
+
+      unformat_init_string (
+	&input, (const char *) flow->generic.pattern.mask,
+	strlen ((const char *) flow->generic.pattern.mask));
+      unformat_user (&input, unformat_hex_string, &flow_mask);
+      unformat_free (&input);
+
+      oct_flow_parse_state pst = {
+	.nxt_proto = 0,
+	.port = port,
+	.items = item_info,
+	.oct_drv = { .spec = drv_item_spec, .mask = drv_item_mask },
+	.generic = { .spec = flow_spec,
+		     .mask = flow_mask,
+		     .len = vec_len (flow_spec) },
+      };
+
+      rc = oct_flow_generic_pattern_parse (&pst);
+      if (rc)
+	{
+	  vec_free (flow_spec);
+	  vec_free (flow_mask);
+	  return VNET_DEV_ERR_NOT_SUPPORTED;
+	}
+
+      goto parse_flow_actions;
+    }
+
   if (FLOW_IS_ETHERNET_CLASS (flow))
     {
       ethernet_header_t eth_spec = { .type = clib_host_to_net_u16 (
@@ -357,6 +737,7 @@ oct_flow_add (vlib_main_t *vm, vnet_dev_port_t *port, vnet_flow_t *flow,
 end_item_info:
   item_info[layer].type = ROC_NPC_ITEM_TYPE_END;
 
+parse_flow_actions:
   if (flow->actions & VNET_FLOW_ACTION_REDIRECT_TO_QUEUE)
     {
       conf.index = flow->redirect_queue;
@@ -422,6 +803,11 @@ end_item_info:
   if (queues)
     clib_mem_free (queues);
 
+  if (flow_spec)
+    vec_free (flow_spec);
+  if (flow_mask)
+    vec_free (flow_mask);
+
   return rv;
 }
 
diff --git a/src/plugins/dev_octeon/format.c b/src/plugins/dev_octeon/format.c
index e624b84f54e..d0f53013d99 100644
--- a/src/plugins/dev_octeon/format.c
+++ b/src/plugins/dev_octeon/format.c
@@ -25,7 +25,7 @@ format_oct_nix_rx_cqe_desc (u8 *s, va_list *args)
   typeof (d->sg0) *sg0 = &d->sg0;
   typeof (d->sg0) *sg1 = &d->sg1;
 
-  s = format (s, "hdr: cqe_type %u nude %u q %u tag 0x%x", h->cqe_type,
+  s = format (s, "hdr: cqe_type %u nude %u qid %u tag 0x%x", h->cqe_type,
 	      h->node, h->q, h->tag);
   s = format (s, "\n%Uparse:", format_white_space, indent);
 #define _(n, f) s = format (s, " " #n " " f, p->n)
diff --git a/src/plugins/dev_octeon/init.c b/src/plugins/dev_octeon/init.c
index 97a11e0d0d7..fd65ce6d9e2 100644
--- a/src/plugins/dev_octeon/init.c
+++ b/src/plugins/dev_octeon/init.c
@@ -4,7 +4,7 @@
 
 #include <vnet/vnet.h>
 #include <vnet/dev/dev.h>
-#include <vnet/dev/pci.h>
+#include <vnet/dev/bus/pci.h>
 #include <vnet/dev/counters.h>
 #include <vnet/ethernet/ethernet.h>
 #include <vnet/plugin/plugin.h>
@@ -141,6 +141,7 @@ oct_init_nix (vlib_main_t *vm, vnet_dev_t *dev)
         .config_change_validate = oct_port_cfg_change_validate,
         .format_status = format_oct_port_status,
         .format_flow = format_oct_port_flow,
+        .clear_counters = oct_port_clear_counters,
       },
       .data_size = sizeof (oct_port_t),
       .initial_data = &oct_port,
@@ -159,6 +160,7 @@ oct_init_nix (vlib_main_t *vm, vnet_dev_t *dev)
         .alloc = oct_rx_queue_alloc,
         .free = oct_rx_queue_free,
 	.format_info = format_oct_rxq_info,
+        .clear_counters = oct_rxq_clear_counters,
       },
     },
     .tx_queue = {
@@ -173,6 +175,7 @@ oct_init_nix (vlib_main_t *vm, vnet_dev_t *dev)
         .alloc = oct_tx_queue_alloc,
         .free = oct_tx_queue_free,
 	.format_info = format_oct_txq_info,
+        .clear_counters = oct_txq_clear_counters,
       },
     },
   };
@@ -245,6 +248,7 @@ oct_init (vlib_main_t *vm, vnet_dev_t *dev)
     {
     case OCT_DEVICE_TYPE_RVU_PF:
     case OCT_DEVICE_TYPE_RVU_VF:
+    case OCT_DEVICE_TYPE_LBK_VF:
     case OCT_DEVICE_TYPE_SDP_VF:
       return oct_init_nix (vm, dev);
 
diff --git a/src/plugins/dev_octeon/octeon.h b/src/plugins/dev_octeon/octeon.h
index e43cde0a35f..a87a5e3e1ed 100644
--- a/src/plugins/dev_octeon/octeon.h
+++ b/src/plugins/dev_octeon/octeon.h
@@ -12,6 +12,12 @@
 #include <vnet/flow/flow.h>
 #include <vnet/udp/udp.h>
 #include <vnet/ipsec/esp.h>
+#include <vnet/ethernet/packet.h>
+#include <vnet/ip/ip_packet.h>
+#include <vnet/ip/icmp46_packet.h>
+#include <vnet/ip/igmp_packet.h>
+#include <vnet/gre/packet.h>
+#include <vxlan/vxlan.h>
 #include <base/roc_api.h>
 #include <dev_octeon/hw_defs.h>
 
@@ -141,6 +147,17 @@ vnet_dev_rv_t oct_flow_validate_params (vlib_main_t *, vnet_dev_port_t *,
 vnet_dev_rv_t oct_flow_query (vlib_main_t *, vnet_dev_port_t *, u32, uword,
 			      u64 *);
 
+/* counter.c */
+void oct_port_add_counters (vlib_main_t *, vnet_dev_port_t *);
+void oct_port_clear_counters (vlib_main_t *, vnet_dev_port_t *);
+void oct_rxq_clear_counters (vlib_main_t *, vnet_dev_rx_queue_t *);
+void oct_txq_clear_counters (vlib_main_t *, vnet_dev_tx_queue_t *);
+vnet_dev_rv_t oct_port_get_stats (vlib_main_t *, vnet_dev_port_t *);
+vnet_dev_rv_t oct_rxq_get_stats (vlib_main_t *, vnet_dev_port_t *,
+				 vnet_dev_rx_queue_t *);
+vnet_dev_rv_t oct_txq_get_stats (vlib_main_t *, vnet_dev_port_t *,
+				 vnet_dev_tx_queue_t *);
+
 #define log_debug(dev, f, ...)                                                \
   vlib_log (VLIB_LOG_LEVEL_DEBUG, oct_log.class, "%U: " f,                    \
 	    format_vnet_dev_addr, (dev), ##__VA_ARGS__)
diff --git a/src/plugins/dev_octeon/port.c b/src/plugins/dev_octeon/port.c
index d5f78301adf..8ba9041f858 100644
--- a/src/plugins/dev_octeon/port.c
+++ b/src/plugins/dev_octeon/port.c
@@ -4,7 +4,6 @@
 
 #include <vnet/vnet.h>
 #include <vnet/dev/dev.h>
-#include <vnet/dev/pci.h>
 #include <vnet/dev/counters.h>
 #include <dev_octeon/octeon.h>
 #include <dev_octeon/common.h>
@@ -124,6 +123,8 @@ oct_port_init (vlib_main_t *vm, vnet_dev_port_t *port)
 	  return rv;
 	}
 
+  oct_port_add_counters (vm, port);
+
   return VNET_DEV_OK;
 }
 
@@ -172,6 +173,21 @@ oct_port_poll (vlib_main_t *vm, vnet_dev_port_t *port)
   vnet_dev_port_state_changes_t changes = {};
   int rrv;
 
+  if (oct_port_get_stats (vm, port))
+    return;
+
+  foreach_vnet_dev_port_rx_queue (q, port)
+    {
+      if (oct_rxq_get_stats (vm, port, q))
+	return;
+    }
+
+  foreach_vnet_dev_port_tx_queue (q, port)
+    {
+      if (oct_txq_get_stats (vm, port, q))
+	return;
+    }
+
   if (roc_nix_is_lbk (nix))
     {
       link_info.status = 1;
@@ -203,7 +219,8 @@ oct_port_poll (vlib_main_t *vm, vnet_dev_port_t *port)
   if (cd->speed != link_info.speed)
     {
       changes.change.link_speed = 1;
-      changes.link_speed = link_info.speed;
+      /* Convert to Kbps */
+      changes.link_speed = link_info.speed * 1000;
       cd->speed = link_info.speed;
     }
 
@@ -385,7 +402,7 @@ oct_validate_config_promisc_mode (vnet_dev_port_t *port, int enable)
   oct_device_t *cd = vnet_dev_get_data (dev);
   struct roc_nix *nix = cd->nix;
 
-  if (roc_nix_is_vf_or_sdp (nix))
+  if (roc_nix_is_sdp (nix) || roc_nix_is_lbk (nix))
     return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 
   return VNET_DEV_OK;
@@ -405,6 +422,9 @@ oct_op_config_promisc_mode (vlib_main_t *vm, vnet_dev_port_t *port, int enable)
       return oct_roc_err (dev, rv, "roc_nix_npc_promisc_ena_dis failed");
     }
 
+  if (!roc_nix_is_pf (nix))
+    return VNET_DEV_OK;
+
   rv = roc_nix_mac_promisc_mode_enable (nix, enable);
   if (rv)
     {
@@ -416,6 +436,44 @@ oct_op_config_promisc_mode (vlib_main_t *vm, vnet_dev_port_t *port, int enable)
   return VNET_DEV_OK;
 }
 
+static vnet_dev_rv_t
+oct_port_add_del_eth_addr (vlib_main_t *vm, vnet_dev_port_t *port,
+			   vnet_dev_hw_addr_t *addr, int is_add,
+			   int is_primary)
+{
+  vnet_dev_t *dev = port->dev;
+  oct_device_t *cd = vnet_dev_get_data (dev);
+  struct roc_nix *nix = cd->nix;
+  vnet_dev_rv_t rv = VNET_DEV_OK;
+
+  i32 rrv;
+
+  if (is_primary)
+    {
+      if (is_add)
+	{
+	  /* Update mac address at NPC */
+	  rrv = roc_nix_npc_mac_addr_set (nix, (u8 *) addr);
+	  if (rrv)
+	    rv = oct_roc_err (dev, rrv, "roc_nix_npc_mac_addr_set() failed");
+
+	  /* Update mac address at CGX for PFs only */
+	  if (!roc_nix_is_vf_or_sdp (nix))
+	    {
+	      rrv = roc_nix_mac_addr_set (nix, (u8 *) addr);
+	      if (rrv)
+		{
+		  /* Rollback to previous mac address */
+		  roc_nix_npc_mac_addr_set (nix,
+					    (u8 *) &port->primary_hw_addr);
+		  rv = oct_roc_err (dev, rrv, "roc_nix_mac_addr_set() failed");
+		}
+	    }
+	}
+    }
+  return rv;
+}
+
 vnet_dev_rv_t
 oct_port_cfg_change_validate (vlib_main_t *vm, vnet_dev_port_t *port,
 			      vnet_dev_port_cfg_change_req_t *req)
@@ -465,6 +523,9 @@ oct_port_cfg_change (vlib_main_t *vm, vnet_dev_port_t *port,
       break;
 
     case VNET_DEV_PORT_CFG_CHANGE_PRIMARY_HW_ADDR:
+      rv = oct_port_add_del_eth_addr (vm, port, &req->addr,
+				      /* is_add */ 1,
+				      /* is_primary */ 1);
       break;
 
     case VNET_DEV_PORT_CFG_ADD_SECONDARY_HW_ADDR:
diff --git a/src/plugins/dev_octeon/queue.c b/src/plugins/dev_octeon/queue.c
index d6ae794fb8d..58d391b8508 100644
--- a/src/plugins/dev_octeon/queue.c
+++ b/src/plugins/dev_octeon/queue.c
@@ -4,7 +4,6 @@
 
 #include <vnet/vnet.h>
 #include <vnet/dev/dev.h>
-#include <vnet/dev/pci.h>
 #include <vnet/dev/counters.h>
 #include <dev_octeon/octeon.h>
 #include <vnet/ethernet/ethernet.h>
diff --git a/src/plugins/dev_octeon/roc_helper.c b/src/plugins/dev_octeon/roc_helper.c
index f10c2cb578b..16e0a871a9d 100644
--- a/src/plugins/dev_octeon/roc_helper.c
+++ b/src/plugins/dev_octeon/roc_helper.c
@@ -49,6 +49,12 @@ oct_plt_get_thread_index (void)
   return __os_thread_index;
 }
 
+static u64
+oct_plt_get_cache_line_size (void)
+{
+  return CLIB_CACHE_LINE_BYTES;
+}
+
 static void
 oct_drv_physmem_free (vlib_main_t *vm, void *mem)
 {
@@ -178,4 +184,5 @@ oct_plt_init_param_t oct_plt_init_param = {
   .oct_plt_spinlock_unlock = oct_plt_spinlock_unlock,
   .oct_plt_spinlock_trylock = oct_plt_spinlock_trylock,
   .oct_plt_get_thread_index = oct_plt_get_thread_index,
+  .oct_plt_get_cache_line_size = oct_plt_get_cache_line_size,
 };
diff --git a/src/plugins/dev_octeon/rx_node.c b/src/plugins/dev_octeon/rx_node.c
index 997f1356199..1f8d5d93fa3 100644
--- a/src/plugins/dev_octeon/rx_node.c
+++ b/src/plugins/dev_octeon/rx_node.c
@@ -165,6 +165,38 @@ oct_rx_batch (vlib_main_t *vm, oct_rx_node_ctx_t *ctx,
   return n;
 }
 
+#ifdef PLATFORM_OCTEON9
+static_always_inline u32
+oct_rxq_refill (vlib_main_t *vm, vnet_dev_rx_queue_t *rxq, u16 n_refill)
+{
+  u32 n_alloc, n_free;
+  u32 buffer_indices[n_refill];
+  vlib_buffer_t *buffers[n_refill];
+  u8 bpi = vnet_dev_get_rx_queue_buffer_pool_index (rxq);
+  oct_rxq_t *crq = vnet_dev_get_rx_queue_data (rxq);
+  u64 aura = roc_npa_aura_handle_to_aura (crq->aura_handle);
+  const uint64_t addr =
+    roc_npa_aura_handle_to_base (crq->aura_handle) + NPA_LF_AURA_OP_FREE0;
+
+  if (n_refill < 256)
+    return 0;
+
+  n_alloc = vlib_buffer_alloc (vm, buffer_indices, n_refill);
+  if (PREDICT_FALSE (n_alloc < n_refill))
+    goto alloc_fail;
+
+  vlib_get_buffers (vm, buffer_indices, (vlib_buffer_t **) buffers, n_alloc);
+
+  for (n_free = 0; n_free < n_alloc; n_free++)
+    roc_store_pair ((u64) buffers[n_free], aura, addr);
+
+  return n_alloc;
+
+alloc_fail:
+  vlib_buffer_unalloc_to_pool (vm, buffer_indices, n_alloc, bpi);
+  return 0;
+}
+#else
 static_always_inline void
 oct_rxq_refill_batch (vlib_main_t *vm, u64 lmt_id, u64 addr,
 		      oct_npa_lf_aura_batch_free_line_t *lines, u32 *bi,
@@ -260,6 +292,7 @@ oct_rxq_refill (vlib_main_t *vm, vnet_dev_rx_queue_t *rxq, u16 n_refill)
 
   return n_enq;
 }
+#endif
 
 static_always_inline void
 oct_rx_trace (vlib_main_t *vm, vlib_node_runtime_t *node,
diff --git a/src/plugins/dev_octeon/tx_node.c b/src/plugins/dev_octeon/tx_node.c
index a2e4b07de8a..0907493814d 100644
--- a/src/plugins/dev_octeon/tx_node.c
+++ b/src/plugins/dev_octeon/tx_node.c
@@ -32,6 +32,44 @@ typedef struct
   lmt_line_t *lmt_lines;
 } oct_tx_ctx_t;
 
+#ifdef PLATFORM_OCTEON9
+static_always_inline u32
+oct_batch_free (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq)
+{
+  oct_txq_t *ctq = vnet_dev_get_tx_queue_data (txq);
+  u16 off = ctq->hdr_off;
+  u64 ah = ctq->aura_handle;
+  u32 n_freed = 0, n;
+
+  ah = ctq->aura_handle;
+
+  if ((n = roc_npa_aura_op_available (ah)) >= 32)
+    {
+      u64 buffers[n];
+      u32 bi[n];
+
+      n_freed = roc_npa_aura_op_bulk_alloc (ah, buffers, n, 0, 1);
+      vlib_get_buffer_indices_with_offset (vm, (void **) &buffers, bi, n_freed,
+					   off);
+      vlib_buffer_free_no_next (vm, bi, n_freed);
+    }
+
+  return n_freed;
+}
+
+static_always_inline void
+oct_lmt_copy (void *lmt_addr, u64 io_addr, void *desc, u64 dwords)
+{
+  u64 lmt_status;
+
+  do
+    {
+      roc_lmt_mov_seg (lmt_addr, desc, dwords);
+      lmt_status = roc_lmt_submit_ldeor (io_addr);
+    }
+  while (lmt_status == 0);
+}
+#else
 static_always_inline u32
 oct_batch_free (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq)
 {
@@ -133,6 +171,7 @@ oct_batch_free (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq)
 
   return n_freed;
 }
+#endif
 
 static_always_inline u8
 oct_tx_enq1 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vlib_buffer_t *b,
@@ -158,6 +197,11 @@ oct_tx_enq1 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vlib_buffer_t *b,
       return 0;
     }
 
+#ifdef PLATFORM_OCTEON9
+  /* Override line for Octeon9 */
+  line = ctx->lmt_lines;
+#endif
+
   if (!simple && flags & VLIB_BUFFER_NEXT_PRESENT)
     {
       u8 n_tail_segs = 0;
@@ -238,8 +282,12 @@ oct_tx_enq1 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vlib_buffer_t *b,
       t->sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
     }
 
+#ifdef PLATFORM_OCTEON9
+  oct_lmt_copy (line, ctx->lmt_ioaddr, &d, n_dwords);
+#else
   for (u32 i = 0; i < n_dwords; i++)
     line->dwords[i] = d.as_u128[i];
+#endif
 
   *dpl = n_dwords;
   *n = *n + 1;
@@ -252,7 +300,7 @@ oct_tx_enq16 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq,
 	      vlib_buffer_t **b, u32 n_pkts, int trace)
 {
   u8 dwords_per_line[16], *dpl = dwords_per_line;
-  u64 lmt_arg, ioaddr, n_lines;
+  u64 __attribute__ ((unused)) lmt_arg, ioaddr, n_lines;
   u32 n_left, or_flags_16 = 0, n = 0;
   const u32 not_simple_flags =
     VLIB_BUFFER_NEXT_PRESENT | VNET_BUFFER_F_OFFLOAD;
@@ -331,6 +379,7 @@ oct_tx_enq16 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq,
   if (PREDICT_FALSE (!n_lines))
     return n_pkts;
 
+#ifndef PLATFORM_OCTEON9
   if (PREDICT_FALSE (or_flags_16 & VLIB_BUFFER_NEXT_PRESENT))
     {
       dpl = dwords_per_line;
@@ -359,6 +408,7 @@ oct_tx_enq16 (vlib_main_t *vm, oct_tx_ctx_t *ctx, vnet_dev_tx_queue_t *txq,
     }
 
   roc_lmt_submit_steorl (lmt_arg, ioaddr);
+#endif
 
   return n_pkts;
 }
@@ -375,7 +425,11 @@ VNET_DEV_NODE_FN (oct_tx_node)
   u32 *from = vlib_frame_vector_args (frame);
   u32 n, n_enq, n_left, n_pkts = frame->n_vectors;
   vlib_buffer_t *buffers[VLIB_FRAME_SIZE + 8], **b = buffers;
+#ifdef PLATFORM_OCTEON9
+  u64 lmt_id = 0;
+#else
   u64 lmt_id = vm->thread_index << ROC_LMT_LINES_PER_CORE_LOG2;
+#endif
 
   oct_tx_ctx_t ctx = {
     .node = node,