qca-nss-drv/nss_virt_if.c - manifest_repos/sdk - Git at Google

 /*
  **************************************************************************
  * Copyright (c) 2014-2020, The Linux Foundation. All rights reserved.
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all copies.
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  **************************************************************************
  */

 /*
  * nss_virt_if.c
  *	NSS virtual/redirect handler APIs
  */

 #include "nss_tx_rx_common.h"
 #include "nss_virt_if_stats.h"
 #include <net/arp.h>

 #define NSS_VIRT_IF_TX_TIMEOUT			3000 /* 3 Seconds */
 #define NSS_VIRT_IF_GET_INDEX(if_num)	(if_num-NSS_DYNAMIC_IF_START)

 extern int nss_ctl_redirect;

 /*
  * Data structure that holds the virtual interface context.
  */
 struct nss_virt_if_handle *nss_virt_if_handle_t[NSS_MAX_DYNAMIC_INTERFACES];

 /*
  * Spinlock to protect the global data structure virt_handle.
  */
 DEFINE_SPINLOCK(nss_virt_if_lock);

 /*
  * nss_virt_if_get_context()
  */
 struct nss_ctx_instance *nss_virt_if_get_context(void)
 {
 	return &nss_top_main.nss[nss_top_main.virt_if_handler_id];
 }

 /*
  * nss_virt_if_verify_if_num()
  *	Verify if_num passed to us.
  */
 bool nss_virt_if_verify_if_num(uint32_t if_num)
 {
 	enum nss_dynamic_interface_type type = nss_dynamic_interface_get_type(nss_virt_if_get_context(), if_num);

 	return type == NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H
 		|| type == NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N;
 }
 EXPORT_SYMBOL(nss_virt_if_verify_if_num);

 /*
  * nss_virt_if_msg_handler()
  *	Handle msg responses from the FW on virtual interfaces
  */
 static void nss_virt_if_msg_handler(struct nss_ctx_instance *nss_ctx,
 					struct nss_cmn_msg *ncm,
 					void *app_data)
 {
 	struct nss_virt_if_msg *nvim = (struct nss_virt_if_msg *)ncm;
 	int32_t if_num;

 	nss_virt_if_msg_callback_t cb;
 	struct nss_virt_if_handle *handle = NULL;

 	/*
 	 * Sanity check the message type
 	 */
 	if (ncm->type > NSS_VIRT_IF_MAX_MSG_TYPES) {
 		nss_warning("%px: message type out of range: %d", nss_ctx, ncm->type);
 		return;
 	}

 	/*
 	 * Messages value that are within the base class are handled by the base class.
 	 */
 	if (ncm->type < NSS_IF_MAX_MSG_TYPES) {
 		return nss_if_msg_handler(nss_ctx, ncm, app_data);
 	}

 	if (!nss_virt_if_verify_if_num(ncm->interface)) {
 		nss_warning("%px: response for another interface: %d", nss_ctx, ncm->interface);
 		return;
 	}

 	if_num = NSS_VIRT_IF_GET_INDEX(ncm->interface);

 	spin_lock_bh(&nss_virt_if_lock);
 	if (!nss_virt_if_handle_t[if_num]) {
 		spin_unlock_bh(&nss_virt_if_lock);
 		nss_warning("%px: virt_if handle is NULL\n", nss_ctx);
 		return;
 	}

 	handle = nss_virt_if_handle_t[if_num];
 	spin_unlock_bh(&nss_virt_if_lock);

 	switch (nvim->cm.type) {
 	case NSS_VIRT_IF_STATS_SYNC_MSG:
 		nss_virt_if_stats_sync(handle, &nvim->msg.stats);
 		break;
 	}

 	/*
 	 * Log failures
 	 */
 	nss_core_log_msg_failures(nss_ctx, ncm);

 	/*
 	 * Update the callback and app_data for NOTIFY messages, IPv4 sends all notify messages
 	 * to the same callback/app_data.
 	 */
 	if (ncm->response == NSS_CMN_RESPONSE_NOTIFY) {
 		ncm->cb = (nss_ptr_t)nss_core_get_msg_handler(nss_ctx, ncm->interface);
 		ncm->app_data = (nss_ptr_t)nss_ctx->subsys_dp_register[ncm->interface].ndev;
 	}

 	/*
 	 * Do we have a callback?
 	 */
 	if (!ncm->cb) {
 		return;
 	}

 	/*
 	 * Callback
 	 */
 	cb = (nss_virt_if_msg_callback_t)ncm->cb;
 	cb((void *)ncm->app_data, ncm);
 }

 /*
  * nss_virt_if_callback
  *	Callback to handle the completion of NSS ->HLOS messages.
  */
 static void nss_virt_if_callback(void *app_data, struct nss_cmn_msg *ncm)
 {
 	struct nss_virt_if_handle *handle = (struct nss_virt_if_handle *)app_data;
 	struct nss_virt_if_pvt *nvip = handle->pvt;

 	if (ncm->response != NSS_CMN_RESPONSE_ACK) {
 		nss_warning("%px: virt_if Error response %d\n", handle->nss_ctx, ncm->response);
 		nvip->response = NSS_TX_FAILURE;
 		complete(&nvip->complete);
 		return;
 	}

 	nvip->response = NSS_TX_SUCCESS;
 	complete(&nvip->complete);
 }

 /*
  * nss_virt_if_tx_msg_sync
  *	Send a message from HLOS to NSS synchronously.
  */
 static nss_tx_status_t nss_virt_if_tx_msg_sync(struct nss_virt_if_handle *handle,
 						struct nss_virt_if_msg *nvim)
 {
 	nss_tx_status_t status;
 	int ret = 0;
 	struct nss_virt_if_pvt *nwip = handle->pvt;
 	struct nss_ctx_instance *nss_ctx = handle->nss_ctx;

 	down(&nwip->sem);

 	status = nss_virt_if_tx_msg(nss_ctx, nvim);
 	if (status != NSS_TX_SUCCESS) {
 		nss_warning("%px: nss_virt_if_msg failed\n", nss_ctx);
 		up(&nwip->sem);
 		return status;
 	}

 	ret = wait_for_completion_timeout(&nwip->complete,
 						msecs_to_jiffies(NSS_VIRT_IF_TX_TIMEOUT));
 	if (!ret) {
 		nss_warning("%px: virt_if tx failed due to timeout\n", nss_ctx);
 		nwip->response = NSS_TX_FAILURE;
 	}

 	status = nwip->response;
 	up(&nwip->sem);

 	return status;
 }

 /*
  * nss_virt_if_msg_init()
  *	Initialize virt specific message structure.
  */
 static void nss_virt_if_msg_init(struct nss_virt_if_msg *nvim,
 					uint16_t if_num,
 					uint32_t type,
 					uint32_t len,
 					nss_virt_if_msg_callback_t cb,
 					struct nss_virt_if_handle *app_data)
 {
 	nss_cmn_msg_init(&nvim->cm, if_num, type, len, (void *)cb, (void *)app_data);
 }

 /*
  * nss_virt_if_handle_destroy_sync()
  *	Destroy the virt handle either due to request from user or due to error, synchronously.
  */
 static int nss_virt_if_handle_destroy_sync(struct nss_virt_if_handle *handle)
 {
 	nss_tx_status_t status;
 	int32_t if_num_n2h = handle->if_num_n2h;
 	int32_t if_num_h2n = handle->if_num_h2n;
 	int32_t index_n2h;
 	int32_t index_h2n;

 	if (!nss_virt_if_verify_if_num(if_num_n2h) || !nss_virt_if_verify_if_num(if_num_h2n)) {
 		nss_warning("%px: bad interface numbers %d %d\n", handle->nss_ctx, if_num_n2h, if_num_h2n);
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	index_n2h = NSS_VIRT_IF_GET_INDEX(if_num_n2h);
 	index_h2n = NSS_VIRT_IF_GET_INDEX(if_num_h2n);

 	status = nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
 	if (status != NSS_TX_SUCCESS) {
 		nss_warning("%px: Dynamic interface destroy failed status %d\n", handle->nss_ctx, status);
 		return status;
 	}

 	status = nss_dynamic_interface_dealloc_node(if_num_h2n, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
 	if (status != NSS_TX_SUCCESS) {
 		nss_warning("%px: Dynamic interface destroy failed status %d\n", handle->nss_ctx, status);
 		return status;
 	}

 	spin_lock_bh(&nss_virt_if_lock);
 	nss_virt_if_handle_t[index_n2h] = NULL;
 	nss_virt_if_handle_t[index_h2n] = NULL;
 	spin_unlock_bh(&nss_virt_if_lock);

 	kfree(handle->pvt);
 	kfree(handle);

 	return status;
 }

 /*
  * nss_virt_if_handle_create_sync()
  *	Initialize virt handle which holds the if_num and stats per interface.
  */
 static struct nss_virt_if_handle *nss_virt_if_handle_create_sync(struct nss_ctx_instance *nss_ctx, int32_t if_num_n2h, int32_t if_num_h2n, int32_t *cmd_rsp)
 {
 	int32_t index_n2h;
 	int32_t index_h2n;
 	struct nss_virt_if_handle *handle;

 	if (!nss_virt_if_verify_if_num(if_num_n2h) || !nss_virt_if_verify_if_num(if_num_h2n)) {
 		nss_warning("%px: bad interface numbers %d %d\n", nss_ctx, if_num_n2h, if_num_h2n);
 		return NULL;
 	}

 	index_n2h = NSS_VIRT_IF_GET_INDEX(if_num_n2h);
 	index_h2n = NSS_VIRT_IF_GET_INDEX(if_num_h2n);

 	handle = (struct nss_virt_if_handle *)kzalloc(sizeof(struct nss_virt_if_handle),
 									GFP_KERNEL);
 	if (!handle) {
 		nss_warning("%px: handle memory alloc failed\n", nss_ctx);
 		*cmd_rsp = NSS_VIRT_IF_ALLOC_FAILURE;
 		goto error1;
 	}

 	handle->nss_ctx = nss_ctx;
 	handle->if_num_n2h = if_num_n2h;
 	handle->if_num_h2n = if_num_h2n;
 	handle->pvt = (struct nss_virt_if_pvt *)kzalloc(sizeof(struct nss_virt_if_pvt),
 								GFP_KERNEL);
 	if (!handle->pvt) {
 		nss_warning("%px: failure allocating memory for nss_virt_if_pvt\n", nss_ctx);
 		*cmd_rsp = NSS_VIRT_IF_ALLOC_FAILURE;
 		goto error2;
 	}

 	handle->cb = NULL;
 	handle->app_data = NULL;

 	spin_lock_bh(&nss_virt_if_lock);
 	nss_virt_if_handle_t[index_n2h] = handle;
 	nss_virt_if_handle_t[index_h2n] = handle;
 	spin_unlock_bh(&nss_virt_if_lock);

 	*cmd_rsp = NSS_VIRT_IF_SUCCESS;

 	return handle;

 error2:
 	kfree(handle);
 error1:
 	return NULL;
 }

 /*
  * nss_virt_if_register_handler_sync()
  * 	register msg handler for virtual interface and initialize semaphore and completion.
  */
 static uint32_t nss_virt_if_register_handler_sync(struct nss_ctx_instance *nss_ctx, struct nss_virt_if_handle *handle)
 {
 	uint32_t ret;
 	struct nss_virt_if_pvt *nvip = NULL;
 	int32_t if_num_n2h = handle->if_num_n2h;
 	int32_t if_num_h2n = handle->if_num_h2n;

 	ret = nss_core_register_handler(nss_ctx, if_num_n2h, nss_virt_if_msg_handler, NULL);
 	if (ret != NSS_CORE_STATUS_SUCCESS) {
 		nss_warning("%px: Failed to register message handler for redir_n2h interface %d\n", nss_ctx, if_num_n2h);
 		return NSS_VIRT_IF_CORE_FAILURE;
 	}

 	ret = nss_core_register_handler(nss_ctx, if_num_h2n, nss_virt_if_msg_handler, NULL);
 	if (ret != NSS_CORE_STATUS_SUCCESS) {
 		nss_core_unregister_handler(nss_ctx, if_num_n2h);
 		nss_warning("%px: Failed to register message handler for redir_h2n interface %d\n", nss_ctx, if_num_h2n);
 		return NSS_VIRT_IF_CORE_FAILURE;
 	}

 	nvip = handle->pvt;
 	if (!nvip->sem_init_done) {
 		sema_init(&nvip->sem, 1);
 		init_completion(&nvip->complete);
 		nvip->sem_init_done = 1;
 	}

 	nss_virt_if_stats_dentry_create();
 	return NSS_VIRT_IF_SUCCESS;
 }

 /*
  * nss_virt_if_create_sync_nexthop()
  *	Create redir_n2h and redir_h2n interfaces, synchronously and associate it with same netdev.
  */
 struct nss_virt_if_handle *nss_virt_if_create_sync_nexthop(struct net_device *netdev, uint32_t nexthop_n2h, uint32_t nexthop_h2n)
 {
 	struct nss_ctx_instance *nss_ctx = nss_virt_if_get_context();
 	struct nss_virt_if_msg nvim;
 	struct nss_virt_if_config_msg *nvcm;
 	uint32_t ret;
 	struct nss_virt_if_handle *handle = NULL;
 	int32_t if_num_n2h, if_num_h2n;

 	if (unlikely(nss_ctx->state != NSS_CORE_STATE_INITIALIZED)) {
 		nss_warning("%px: Interface could not be created as core not ready\n", nss_ctx);
 		return NULL;
 	}

 	if_num_n2h = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
 	if (if_num_n2h < 0) {
 		nss_warning("%px: failure allocating redir_n2h\n", nss_ctx);
 		return NULL;
 	}

 	if_num_h2n = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
 	if (if_num_h2n < 0) {
 		nss_warning("%px: failure allocating redir_h2n\n", nss_ctx);
 		nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
 		return NULL;
 	}

 	handle = nss_virt_if_handle_create_sync(nss_ctx, if_num_n2h, if_num_h2n, &ret);
 	if (!handle) {
 		nss_warning("%px: virt_if handle creation failed ret %d\n", nss_ctx, ret);
 		nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
 		nss_dynamic_interface_dealloc_node(if_num_h2n, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
 		return NULL;
 	}

 	/*
 	 * Initializes the semaphore and also sets the msg handler for if_num.
 	 */
 	ret = nss_virt_if_register_handler_sync(nss_ctx, handle);
 	if (ret != NSS_VIRT_IF_SUCCESS) {
 		nss_warning("%px: Registration handler failed reason: %d\n", nss_ctx, ret);
 		goto error1;
 	}

 	nss_virt_if_msg_init(&nvim, handle->if_num_n2h, NSS_VIRT_IF_TX_CONFIG_MSG,
 				sizeof(struct nss_virt_if_config_msg), nss_virt_if_callback, handle);

 	nvcm = &nvim.msg.if_config;
 	nvcm->flags = 0;
 	nvcm->sibling = if_num_h2n;
 	nvcm->nexthop = nexthop_n2h;
 	memcpy(nvcm->mac_addr, netdev->dev_addr, ETH_ALEN);

 	ret = nss_virt_if_tx_msg_sync(handle, &nvim);
 	if (ret != NSS_TX_SUCCESS) {
 		nss_warning("%px: nss_virt_if_tx_msg_sync failed %u\n", nss_ctx, ret);
 		goto error2;
 	}

 	nvim.cm.interface = if_num_h2n;
 	nvcm->sibling = if_num_n2h;
 	nvcm->nexthop = nexthop_h2n;

 	ret = nss_virt_if_tx_msg_sync(handle, &nvim);
 	if (ret != NSS_TX_SUCCESS) {
 		nss_warning("%px: nss_virt_if_tx_msg_sync failed %u\n", nss_ctx, ret);
 		goto error2;
 	}

 	nss_core_register_subsys_dp(nss_ctx, handle->if_num_n2h, NULL, NULL, NULL, netdev, 0);
 	nss_core_register_subsys_dp(nss_ctx, handle->if_num_h2n, NULL, NULL, NULL, netdev, 0);

 	nss_core_set_subsys_dp_type(nss_ctx, netdev, if_num_n2h, NSS_VIRT_IF_DP_REDIR_N2H);
 	nss_core_set_subsys_dp_type(nss_ctx, netdev, if_num_h2n, NSS_VIRT_IF_DP_REDIR_H2N);

 	/*
 	 * Hold a reference to the net_device
 	 */
 	dev_hold(netdev);

 	/*
 	 * The context returned is the handle interface # which contains all the info related to
 	 * the interface if_num.
 	 */

 	return handle;

 error2:
 	nss_core_unregister_handler(nss_ctx, if_num_n2h);
 	nss_core_unregister_handler(nss_ctx, if_num_h2n);

 error1:
 	nss_virt_if_handle_destroy_sync(handle);
 	return NULL;
 }
 EXPORT_SYMBOL(nss_virt_if_create_sync_nexthop);

 /*
  * nss_virt_if_create_sync()
  *	Create redir_n2h and redir_h2n interfaces, synchronously and associate it with same netdev.
  * It uses the default nexthop interfaces.
  *
  *
  */
 struct nss_virt_if_handle *nss_virt_if_create_sync(struct net_device *netdev)
 {
 	/*
 	 * NSS_N2H_INTERFACE is the nexthop of the dynamic interface which is created for handling the
 	 * n2h traffic.
 	 * NSS_ETH_RX_INTERFACE is the nexthop of the dynamic interface which is created for handling the
 	 * h2n traffic.
 	 */
 	return nss_virt_if_create_sync_nexthop(netdev, NSS_N2H_INTERFACE, NSS_ETH_RX_INTERFACE);
 }
 EXPORT_SYMBOL(nss_virt_if_create_sync);

 /*
  * nss_virt_if_destroy_sync()
  *	Destroy the virt interface associated with the interface number, synchronously.
  */
 nss_tx_status_t nss_virt_if_destroy_sync(struct nss_virt_if_handle *handle)
 {
 	nss_tx_status_t status;
 	struct net_device *dev;
 	int32_t if_num_n2h;
 	int32_t if_num_h2n;
 	struct nss_ctx_instance *nss_ctx;
 	uint32_t ret;

 	if (!handle) {
 		nss_warning("handle is NULL\n");
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	if_num_n2h = handle->if_num_n2h;
 	if_num_h2n = handle->if_num_h2n;
 	nss_ctx = handle->nss_ctx;

 	if (unlikely(nss_ctx->state != NSS_CORE_STATE_INITIALIZED)) {
 		nss_warning("%px: Interface could not be destroyed as core not ready\n", nss_ctx);
 		return NSS_TX_FAILURE_NOT_READY;
 	}

 	spin_lock_bh(&nss_top_main.lock);
 	if (!nss_ctx->subsys_dp_register[if_num_n2h].ndev || !nss_ctx->subsys_dp_register[if_num_h2n].ndev) {
 		spin_unlock_bh(&nss_top_main.lock);
 		nss_warning("%px: Unregister virt interface %d %d: no context\n", nss_ctx, if_num_n2h, if_num_h2n);
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	dev = nss_ctx->subsys_dp_register[if_num_n2h].ndev;
 	nss_assert(dev == nss_ctx->subsys_dp_register[if_num_h2n].ndev);
 	nss_core_unregister_subsys_dp(nss_ctx, if_num_n2h);
 	nss_core_unregister_subsys_dp(nss_ctx, if_num_h2n);
 	spin_unlock_bh(&nss_top_main.lock);
 	dev_put(dev);

 	status = nss_virt_if_handle_destroy_sync(handle);
 	if (status != NSS_TX_SUCCESS) {
 		nss_warning("%px: handle destroy failed for if_num_n2h %d and if_num_h2n %d\n", nss_ctx, if_num_n2h, if_num_h2n);
 		return NSS_TX_FAILURE;
 	}

 	ret = nss_core_unregister_handler(nss_ctx, if_num_n2h);
 	if (ret != NSS_CORE_STATUS_SUCCESS) {
 		nss_warning("%px: Not able to unregister handler for redir_n2h interface %d with NSS core\n", nss_ctx, if_num_n2h);
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	ret = nss_core_unregister_handler(nss_ctx, if_num_h2n);
 	if (ret != NSS_CORE_STATUS_SUCCESS) {
 		nss_warning("%px: Not able to unregister handler for redir_h2n interface %d with NSS core\n", nss_ctx, if_num_h2n);
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	return status;
 }
 EXPORT_SYMBOL(nss_virt_if_destroy_sync);

 /*
  * nss_virt_if_tx_buf()
  *	HLOS interface has received a packet which we redirect to the NSS, if appropriate to do so.
  */
 nss_tx_status_t nss_virt_if_tx_buf(struct nss_virt_if_handle *handle,
 						struct sk_buff *skb)
 {
 	int32_t if_num = handle->if_num_h2n;
 	struct nss_ctx_instance *nss_ctx = handle->nss_ctx;
 	int cpu = 0;

 	if (unlikely(nss_ctl_redirect == 0)) {
 		return NSS_TX_FAILURE_NOT_ENABLED;
 	}

 	if (unlikely(skb->vlan_tci)) {
 		return NSS_TX_FAILURE_NOT_SUPPORTED;
 	}

 	if (!nss_virt_if_verify_if_num(if_num)) {
 		nss_warning("%px: bad interface number %d\n", nss_ctx, if_num);
 		return NSS_TX_FAILURE_BAD_PARAM;
 	}

 	nss_trace("%px: Virtual Rx packet, if_num:%d, skb:%px", nss_ctx, if_num, skb);

 	/*
 	 * Sanity check the SKB to ensure that it's suitable for us
 	 */
 	if (unlikely(skb->len <= ETH_HLEN)) {
 		nss_warning("%px: Virtual Rx packet: %px too short", nss_ctx, skb);
 		return NSS_TX_FAILURE_TOO_SHORT;
 	}

 	/*
 	 * set skb queue mapping
 	 */
 	cpu = get_cpu();
 	put_cpu();
 	skb_set_queue_mapping(skb, cpu);

 	return nss_core_send_packet(nss_ctx, skb, if_num, H2N_BIT_FLAG_VIRTUAL_BUFFER |
                                                         H2N_BIT_FLAG_BUFFER_REUSABLE);
 }
 EXPORT_SYMBOL(nss_virt_if_tx_buf);

 /*
  * nss_virt_if_tx_msg()
  */
 nss_tx_status_t nss_virt_if_tx_msg(struct nss_ctx_instance *nss_ctx, struct nss_virt_if_msg *nvim)
 {
 	struct nss_cmn_msg *ncm = &nvim->cm;

 	/*
 	 * Sanity check the message
 	 */
 	if (!nss_virt_if_verify_if_num(ncm->interface)) {
 		nss_warning("%px: tx request for another interface: %d", nss_ctx, ncm->interface);
 		return NSS_TX_FAILURE;
 	}

 	if (ncm->type > NSS_VIRT_IF_MAX_MSG_TYPES) {
 		nss_warning("%px: message type out of range: %d", nss_ctx, ncm->type);
 		return NSS_TX_FAILURE;
 	}

 	return nss_core_send_cmd(nss_ctx, nvim, sizeof(*nvim), NSS_NBUF_PAYLOAD_SIZE);
 }
 EXPORT_SYMBOL(nss_virt_if_tx_msg);

 /*
  * nss_virt_if_xmit_callback_register()
  *	Register virtual interface xmit callback.
  */
 void nss_virt_if_xmit_callback_register(struct nss_virt_if_handle *handle,
 				nss_virt_if_xmit_callback_t cb)
 {
 	struct nss_ctx_instance *nss_ctx;
 	struct nss_subsystem_dataplane_register *reg;

 	if (!handle) {
 		nss_warning("handle is NULL\n");
 		return;
 	}

 	nss_ctx = handle->nss_ctx;
 	NSS_VERIFY_CTX_MAGIC(nss_ctx);

 	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
 		nss_warning("if_num is invalid\n");
 		return;
 	}

 	reg = &nss_ctx->subsys_dp_register[handle->if_num_n2h];
 	reg->xmit_cb = cb;
 }
 EXPORT_SYMBOL(nss_virt_if_xmit_callback_register);

 /*
  * nss_virt_if_xmit_callback_unregister()
  *	Unregister virtual interface xmit callback.
  */
 void nss_virt_if_xmit_callback_unregister(struct nss_virt_if_handle *handle)
 {
 	struct nss_ctx_instance *nss_ctx;
 	struct nss_subsystem_dataplane_register *reg;

 	if (!handle) {
 		nss_warning("handle is NULL\n");
 		return;
 	}

 	nss_ctx = handle->nss_ctx;
 	NSS_VERIFY_CTX_MAGIC(nss_ctx);

 	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
 		nss_warning("if_num is invalid\n");
 		return;
 	}

 	reg = &nss_ctx->subsys_dp_register[handle->if_num_n2h];
 	reg->xmit_cb = NULL;
 }
 EXPORT_SYMBOL(nss_virt_if_xmit_callback_unregister);

 /*
  * nss_virt_if_register()
  */
 void nss_virt_if_register(struct nss_virt_if_handle *handle,
 				nss_virt_if_data_callback_t data_callback,
 				struct net_device *netdev)
 {
 	struct nss_ctx_instance *nss_ctx;
 	int32_t if_num;
 	uint32_t status;

 	if (!handle) {
 		nss_warning("handle is NULL\n");
 		return;
 	}

 	nss_ctx = handle->nss_ctx;
 	NSS_VERIFY_CTX_MAGIC(nss_ctx);

 	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
 		nss_warning("if_num is invalid\n");
 		return;
 	}

 	if_num = handle->if_num_n2h;

 	nss_core_register_subsys_dp(nss_ctx, if_num, data_callback, NULL, NULL, netdev, (uint32_t)netdev->features);
 	status = nss_core_unregister_msg_handler(nss_ctx, if_num);
 	if (status != NSS_CORE_STATUS_SUCCESS) {
 		nss_warning("%px: unable to unregister event handler for interface(%u)", nss_ctx, if_num);
 		return;
 	}
 }
 EXPORT_SYMBOL(nss_virt_if_register);

 /*
  * nss_virt_if_unregister()
  */
 void nss_virt_if_unregister(struct nss_virt_if_handle *handle)
 {
 	struct nss_ctx_instance *nss_ctx;
 	int32_t if_num;
 	uint32_t status;

 	if (!handle) {
 		nss_warning("handle is NULL\n");
 		return;
 	}

 	nss_ctx = handle->nss_ctx;
 	NSS_VERIFY_CTX_MAGIC(nss_ctx);

 	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
 		nss_warning("if_num is invalid\n");
 		return;
 	}

 	if_num = handle->if_num_n2h;

 	nss_core_unregister_subsys_dp(nss_ctx, if_num);

 	status = nss_core_unregister_msg_handler(nss_ctx, if_num);
 	if (status != NSS_CORE_STATUS_SUCCESS) {
 		nss_warning("%px: unable to unregister event handler for interface(%u)", nss_ctx, if_num);
 		return;
 	}
 }
 EXPORT_SYMBOL(nss_virt_if_unregister);

 /*
  * nss_virt_if_get_interface_num()
  *	Get interface number for a virtual interface
  */
 int32_t nss_virt_if_get_interface_num(struct nss_virt_if_handle *handle)
 {
 	if (!handle) {
 		nss_warning("virt_if handle is NULL\n");
 		return -1;
 	}

 	/*
 	 * Return if_num_n2h whose datapath type is 0.
 	 */
 	return handle->if_num_n2h;
 }
 EXPORT_SYMBOL(nss_virt_if_get_interface_num);
	/*
	**************************************************************************
	* Copyright (c) 2014-2020, The Linux Foundation. All rights reserved.
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all copies.
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	**************************************************************************
	*/

	/*
	* nss_virt_if.c
	* NSS virtual/redirect handler APIs
	*/

	#include "nss_tx_rx_common.h"
	#include "nss_virt_if_stats.h"
	#include <net/arp.h>

	#define NSS_VIRT_IF_TX_TIMEOUT 3000 /* 3 Seconds */
	#define NSS_VIRT_IF_GET_INDEX(if_num) (if_num-NSS_DYNAMIC_IF_START)

	extern int nss_ctl_redirect;

	/*
	* Data structure that holds the virtual interface context.
	*/
	struct nss_virt_if_handle *nss_virt_if_handle_t[NSS_MAX_DYNAMIC_INTERFACES];

	/*
	* Spinlock to protect the global data structure virt_handle.
	*/
	DEFINE_SPINLOCK(nss_virt_if_lock);

	/*
	* nss_virt_if_get_context()
	*/
	struct nss_ctx_instance *nss_virt_if_get_context(void)
	{
	return &nss_top_main.nss[nss_top_main.virt_if_handler_id];
	}

	/*
	* nss_virt_if_verify_if_num()
	* Verify if_num passed to us.
	*/
	bool nss_virt_if_verify_if_num(uint32_t if_num)
	{
	enum nss_dynamic_interface_type type = nss_dynamic_interface_get_type(nss_virt_if_get_context(), if_num);

	return type == NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H
	\|\| type == NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N;
	}
	EXPORT_SYMBOL(nss_virt_if_verify_if_num);

	/*
	* nss_virt_if_msg_handler()
	* Handle msg responses from the FW on virtual interfaces
	*/
	static void nss_virt_if_msg_handler(struct nss_ctx_instance *nss_ctx,
	struct nss_cmn_msg *ncm,
	void *app_data)
	{
	struct nss_virt_if_msg nvim = (struct nss_virt_if_msg )ncm;
	int32_t if_num;

	nss_virt_if_msg_callback_t cb;
	struct nss_virt_if_handle *handle = NULL;

	/*
	* Sanity check the message type
	*/
	if (ncm->type > NSS_VIRT_IF_MAX_MSG_TYPES) {
	nss_warning("%px: message type out of range: %d", nss_ctx, ncm->type);
	return;
	}

	/*
	* Messages value that are within the base class are handled by the base class.
	*/
	if (ncm->type < NSS_IF_MAX_MSG_TYPES) {
	return nss_if_msg_handler(nss_ctx, ncm, app_data);
	}

	if (!nss_virt_if_verify_if_num(ncm->interface)) {
	nss_warning("%px: response for another interface: %d", nss_ctx, ncm->interface);
	return;
	}

	if_num = NSS_VIRT_IF_GET_INDEX(ncm->interface);

	spin_lock_bh(&nss_virt_if_lock);
	if (!nss_virt_if_handle_t[if_num]) {
	spin_unlock_bh(&nss_virt_if_lock);
	nss_warning("%px: virt_if handle is NULL\n", nss_ctx);
	return;
	}

	handle = nss_virt_if_handle_t[if_num];
	spin_unlock_bh(&nss_virt_if_lock);

	switch (nvim->cm.type) {
	case NSS_VIRT_IF_STATS_SYNC_MSG:
	nss_virt_if_stats_sync(handle, &nvim->msg.stats);
	break;
	}

	/*
	* Log failures
	*/
	nss_core_log_msg_failures(nss_ctx, ncm);

	/*
	* Update the callback and app_data for NOTIFY messages, IPv4 sends all notify messages
	* to the same callback/app_data.
	*/
	if (ncm->response == NSS_CMN_RESPONSE_NOTIFY) {
	ncm->cb = (nss_ptr_t)nss_core_get_msg_handler(nss_ctx, ncm->interface);
	ncm->app_data = (nss_ptr_t)nss_ctx->subsys_dp_register[ncm->interface].ndev;
	}

	/*
	* Do we have a callback?
	*/
	if (!ncm->cb) {
	return;
	}

	/*
	* Callback
	*/
	cb = (nss_virt_if_msg_callback_t)ncm->cb;
	cb((void *)ncm->app_data, ncm);
	}

	/*
	* nss_virt_if_callback
	* Callback to handle the completion of NSS ->HLOS messages.
	*/
	static void nss_virt_if_callback(void app_data, struct nss_cmn_msg ncm)
	{
	struct nss_virt_if_handle handle = (struct nss_virt_if_handle )app_data;
	struct nss_virt_if_pvt *nvip = handle->pvt;

	if (ncm->response != NSS_CMN_RESPONSE_ACK) {
	nss_warning("%px: virt_if Error response %d\n", handle->nss_ctx, ncm->response);
	nvip->response = NSS_TX_FAILURE;
	complete(&nvip->complete);
	return;
	}

	nvip->response = NSS_TX_SUCCESS;
	complete(&nvip->complete);
	}

	/*
	* nss_virt_if_tx_msg_sync
	* Send a message from HLOS to NSS synchronously.
	*/
	static nss_tx_status_t nss_virt_if_tx_msg_sync(struct nss_virt_if_handle *handle,
	struct nss_virt_if_msg *nvim)
	{
	nss_tx_status_t status;
	int ret = 0;
	struct nss_virt_if_pvt *nwip = handle->pvt;
	struct nss_ctx_instance *nss_ctx = handle->nss_ctx;

	down(&nwip->sem);

	status = nss_virt_if_tx_msg(nss_ctx, nvim);
	if (status != NSS_TX_SUCCESS) {
	nss_warning("%px: nss_virt_if_msg failed\n", nss_ctx);
	up(&nwip->sem);
	return status;
	}

	ret = wait_for_completion_timeout(&nwip->complete,
	msecs_to_jiffies(NSS_VIRT_IF_TX_TIMEOUT));
	if (!ret) {
	nss_warning("%px: virt_if tx failed due to timeout\n", nss_ctx);
	nwip->response = NSS_TX_FAILURE;
	}

	status = nwip->response;
	up(&nwip->sem);

	return status;
	}

	/*
	* nss_virt_if_msg_init()
	* Initialize virt specific message structure.
	*/
	static void nss_virt_if_msg_init(struct nss_virt_if_msg *nvim,
	uint16_t if_num,
	uint32_t type,
	uint32_t len,
	nss_virt_if_msg_callback_t cb,
	struct nss_virt_if_handle *app_data)
	{
	nss_cmn_msg_init(&nvim->cm, if_num, type, len, (void )cb, (void )app_data);
	}

	/*
	* nss_virt_if_handle_destroy_sync()
	* Destroy the virt handle either due to request from user or due to error, synchronously.
	*/
	static int nss_virt_if_handle_destroy_sync(struct nss_virt_if_handle *handle)
	{
	nss_tx_status_t status;
	int32_t if_num_n2h = handle->if_num_n2h;
	int32_t if_num_h2n = handle->if_num_h2n;
	int32_t index_n2h;
	int32_t index_h2n;

	if (!nss_virt_if_verify_if_num(if_num_n2h) \|\| !nss_virt_if_verify_if_num(if_num_h2n)) {
	nss_warning("%px: bad interface numbers %d %d\n", handle->nss_ctx, if_num_n2h, if_num_h2n);
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	index_n2h = NSS_VIRT_IF_GET_INDEX(if_num_n2h);
	index_h2n = NSS_VIRT_IF_GET_INDEX(if_num_h2n);

	status = nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
	if (status != NSS_TX_SUCCESS) {
	nss_warning("%px: Dynamic interface destroy failed status %d\n", handle->nss_ctx, status);
	return status;
	}

	status = nss_dynamic_interface_dealloc_node(if_num_h2n, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
	if (status != NSS_TX_SUCCESS) {
	nss_warning("%px: Dynamic interface destroy failed status %d\n", handle->nss_ctx, status);
	return status;
	}

	spin_lock_bh(&nss_virt_if_lock);
	nss_virt_if_handle_t[index_n2h] = NULL;
	nss_virt_if_handle_t[index_h2n] = NULL;
	spin_unlock_bh(&nss_virt_if_lock);

	kfree(handle->pvt);
	kfree(handle);

	return status;
	}

	/*
	* nss_virt_if_handle_create_sync()
	* Initialize virt handle which holds the if_num and stats per interface.
	*/
	static struct nss_virt_if_handle nss_virt_if_handle_create_sync(struct nss_ctx_instance nss_ctx, int32_t if_num_n2h, int32_t if_num_h2n, int32_t *cmd_rsp)
	{
	int32_t index_n2h;
	int32_t index_h2n;
	struct nss_virt_if_handle *handle;

	if (!nss_virt_if_verify_if_num(if_num_n2h) \|\| !nss_virt_if_verify_if_num(if_num_h2n)) {
	nss_warning("%px: bad interface numbers %d %d\n", nss_ctx, if_num_n2h, if_num_h2n);
	return NULL;
	}

	index_n2h = NSS_VIRT_IF_GET_INDEX(if_num_n2h);
	index_h2n = NSS_VIRT_IF_GET_INDEX(if_num_h2n);

	handle = (struct nss_virt_if_handle *)kzalloc(sizeof(struct nss_virt_if_handle),
	GFP_KERNEL);
	if (!handle) {
	nss_warning("%px: handle memory alloc failed\n", nss_ctx);
	*cmd_rsp = NSS_VIRT_IF_ALLOC_FAILURE;
	goto error1;
	}

	handle->nss_ctx = nss_ctx;
	handle->if_num_n2h = if_num_n2h;
	handle->if_num_h2n = if_num_h2n;
	handle->pvt = (struct nss_virt_if_pvt *)kzalloc(sizeof(struct nss_virt_if_pvt),
	GFP_KERNEL);
	if (!handle->pvt) {
	nss_warning("%px: failure allocating memory for nss_virt_if_pvt\n", nss_ctx);
	*cmd_rsp = NSS_VIRT_IF_ALLOC_FAILURE;
	goto error2;
	}

	handle->cb = NULL;
	handle->app_data = NULL;

	spin_lock_bh(&nss_virt_if_lock);
	nss_virt_if_handle_t[index_n2h] = handle;
	nss_virt_if_handle_t[index_h2n] = handle;
	spin_unlock_bh(&nss_virt_if_lock);

	*cmd_rsp = NSS_VIRT_IF_SUCCESS;

	return handle;

	error2:
	kfree(handle);
	error1:
	return NULL;
	}

	/*
	* nss_virt_if_register_handler_sync()
	* register msg handler for virtual interface and initialize semaphore and completion.
	*/
	static uint32_t nss_virt_if_register_handler_sync(struct nss_ctx_instance nss_ctx, struct nss_virt_if_handle handle)
	{
	uint32_t ret;
	struct nss_virt_if_pvt *nvip = NULL;
	int32_t if_num_n2h = handle->if_num_n2h;
	int32_t if_num_h2n = handle->if_num_h2n;

	ret = nss_core_register_handler(nss_ctx, if_num_n2h, nss_virt_if_msg_handler, NULL);
	if (ret != NSS_CORE_STATUS_SUCCESS) {
	nss_warning("%px: Failed to register message handler for redir_n2h interface %d\n", nss_ctx, if_num_n2h);
	return NSS_VIRT_IF_CORE_FAILURE;
	}

	ret = nss_core_register_handler(nss_ctx, if_num_h2n, nss_virt_if_msg_handler, NULL);
	if (ret != NSS_CORE_STATUS_SUCCESS) {
	nss_core_unregister_handler(nss_ctx, if_num_n2h);
	nss_warning("%px: Failed to register message handler for redir_h2n interface %d\n", nss_ctx, if_num_h2n);
	return NSS_VIRT_IF_CORE_FAILURE;
	}

	nvip = handle->pvt;
	if (!nvip->sem_init_done) {
	sema_init(&nvip->sem, 1);
	init_completion(&nvip->complete);
	nvip->sem_init_done = 1;
	}

	nss_virt_if_stats_dentry_create();
	return NSS_VIRT_IF_SUCCESS;
	}

	/*
	* nss_virt_if_create_sync_nexthop()
	* Create redir_n2h and redir_h2n interfaces, synchronously and associate it with same netdev.
	*/
	struct nss_virt_if_handle nss_virt_if_create_sync_nexthop(struct net_device netdev, uint32_t nexthop_n2h, uint32_t nexthop_h2n)
	{
	struct nss_ctx_instance *nss_ctx = nss_virt_if_get_context();
	struct nss_virt_if_msg nvim;
	struct nss_virt_if_config_msg *nvcm;
	uint32_t ret;
	struct nss_virt_if_handle *handle = NULL;
	int32_t if_num_n2h, if_num_h2n;

	if (unlikely(nss_ctx->state != NSS_CORE_STATE_INITIALIZED)) {
	nss_warning("%px: Interface could not be created as core not ready\n", nss_ctx);
	return NULL;
	}

	if_num_n2h = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
	if (if_num_n2h < 0) {
	nss_warning("%px: failure allocating redir_n2h\n", nss_ctx);
	return NULL;
	}

	if_num_h2n = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
	if (if_num_h2n < 0) {
	nss_warning("%px: failure allocating redir_h2n\n", nss_ctx);
	nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
	return NULL;
	}

	handle = nss_virt_if_handle_create_sync(nss_ctx, if_num_n2h, if_num_h2n, &ret);
	if (!handle) {
	nss_warning("%px: virt_if handle creation failed ret %d\n", nss_ctx, ret);
	nss_dynamic_interface_dealloc_node(if_num_n2h, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_N2H);
	nss_dynamic_interface_dealloc_node(if_num_h2n, NSS_DYNAMIC_INTERFACE_TYPE_GENERIC_REDIR_H2N);
	return NULL;
	}

	/*
	* Initializes the semaphore and also sets the msg handler for if_num.
	*/
	ret = nss_virt_if_register_handler_sync(nss_ctx, handle);
	if (ret != NSS_VIRT_IF_SUCCESS) {
	nss_warning("%px: Registration handler failed reason: %d\n", nss_ctx, ret);
	goto error1;
	}

	nss_virt_if_msg_init(&nvim, handle->if_num_n2h, NSS_VIRT_IF_TX_CONFIG_MSG,
	sizeof(struct nss_virt_if_config_msg), nss_virt_if_callback, handle);

	nvcm = &nvim.msg.if_config;
	nvcm->flags = 0;
	nvcm->sibling = if_num_h2n;
	nvcm->nexthop = nexthop_n2h;
	memcpy(nvcm->mac_addr, netdev->dev_addr, ETH_ALEN);

	ret = nss_virt_if_tx_msg_sync(handle, &nvim);
	if (ret != NSS_TX_SUCCESS) {
	nss_warning("%px: nss_virt_if_tx_msg_sync failed %u\n", nss_ctx, ret);
	goto error2;
	}

	nvim.cm.interface = if_num_h2n;
	nvcm->sibling = if_num_n2h;
	nvcm->nexthop = nexthop_h2n;

	ret = nss_virt_if_tx_msg_sync(handle, &nvim);
	if (ret != NSS_TX_SUCCESS) {
	nss_warning("%px: nss_virt_if_tx_msg_sync failed %u\n", nss_ctx, ret);
	goto error2;
	}

	nss_core_register_subsys_dp(nss_ctx, handle->if_num_n2h, NULL, NULL, NULL, netdev, 0);
	nss_core_register_subsys_dp(nss_ctx, handle->if_num_h2n, NULL, NULL, NULL, netdev, 0);

	nss_core_set_subsys_dp_type(nss_ctx, netdev, if_num_n2h, NSS_VIRT_IF_DP_REDIR_N2H);
	nss_core_set_subsys_dp_type(nss_ctx, netdev, if_num_h2n, NSS_VIRT_IF_DP_REDIR_H2N);

	/*
	* Hold a reference to the net_device
	*/
	dev_hold(netdev);

	/*
	* The context returned is the handle interface # which contains all the info related to
	* the interface if_num.
	*/

	return handle;

	error2:
	nss_core_unregister_handler(nss_ctx, if_num_n2h);
	nss_core_unregister_handler(nss_ctx, if_num_h2n);

	error1:
	nss_virt_if_handle_destroy_sync(handle);
	return NULL;
	}
	EXPORT_SYMBOL(nss_virt_if_create_sync_nexthop);

	/*
	* nss_virt_if_create_sync()
	* Create redir_n2h and redir_h2n interfaces, synchronously and associate it with same netdev.
	* It uses the default nexthop interfaces.
	*
	*
	*/
	struct nss_virt_if_handle nss_virt_if_create_sync(struct net_device netdev)
	{
	/*
	* NSS_N2H_INTERFACE is the nexthop of the dynamic interface which is created for handling the
	* n2h traffic.
	* NSS_ETH_RX_INTERFACE is the nexthop of the dynamic interface which is created for handling the
	* h2n traffic.
	*/
	return nss_virt_if_create_sync_nexthop(netdev, NSS_N2H_INTERFACE, NSS_ETH_RX_INTERFACE);
	}
	EXPORT_SYMBOL(nss_virt_if_create_sync);

	/*
	* nss_virt_if_destroy_sync()
	* Destroy the virt interface associated with the interface number, synchronously.
	*/
	nss_tx_status_t nss_virt_if_destroy_sync(struct nss_virt_if_handle *handle)
	{
	nss_tx_status_t status;
	struct net_device *dev;
	int32_t if_num_n2h;
	int32_t if_num_h2n;
	struct nss_ctx_instance *nss_ctx;
	uint32_t ret;

	if (!handle) {
	nss_warning("handle is NULL\n");
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	if_num_n2h = handle->if_num_n2h;
	if_num_h2n = handle->if_num_h2n;
	nss_ctx = handle->nss_ctx;

	if (unlikely(nss_ctx->state != NSS_CORE_STATE_INITIALIZED)) {
	nss_warning("%px: Interface could not be destroyed as core not ready\n", nss_ctx);
	return NSS_TX_FAILURE_NOT_READY;
	}

	spin_lock_bh(&nss_top_main.lock);
	if (!nss_ctx->subsys_dp_register[if_num_n2h].ndev \|\| !nss_ctx->subsys_dp_register[if_num_h2n].ndev) {
	spin_unlock_bh(&nss_top_main.lock);
	nss_warning("%px: Unregister virt interface %d %d: no context\n", nss_ctx, if_num_n2h, if_num_h2n);
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	dev = nss_ctx->subsys_dp_register[if_num_n2h].ndev;
	nss_assert(dev == nss_ctx->subsys_dp_register[if_num_h2n].ndev);
	nss_core_unregister_subsys_dp(nss_ctx, if_num_n2h);
	nss_core_unregister_subsys_dp(nss_ctx, if_num_h2n);
	spin_unlock_bh(&nss_top_main.lock);
	dev_put(dev);

	status = nss_virt_if_handle_destroy_sync(handle);
	if (status != NSS_TX_SUCCESS) {
	nss_warning("%px: handle destroy failed for if_num_n2h %d and if_num_h2n %d\n", nss_ctx, if_num_n2h, if_num_h2n);
	return NSS_TX_FAILURE;
	}

	ret = nss_core_unregister_handler(nss_ctx, if_num_n2h);
	if (ret != NSS_CORE_STATUS_SUCCESS) {
	nss_warning("%px: Not able to unregister handler for redir_n2h interface %d with NSS core\n", nss_ctx, if_num_n2h);
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	ret = nss_core_unregister_handler(nss_ctx, if_num_h2n);
	if (ret != NSS_CORE_STATUS_SUCCESS) {
	nss_warning("%px: Not able to unregister handler for redir_h2n interface %d with NSS core\n", nss_ctx, if_num_h2n);
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	return status;
	}
	EXPORT_SYMBOL(nss_virt_if_destroy_sync);

	/*
	* nss_virt_if_tx_buf()
	* HLOS interface has received a packet which we redirect to the NSS, if appropriate to do so.
	*/
	nss_tx_status_t nss_virt_if_tx_buf(struct nss_virt_if_handle *handle,
	struct sk_buff *skb)
	{
	int32_t if_num = handle->if_num_h2n;
	struct nss_ctx_instance *nss_ctx = handle->nss_ctx;
	int cpu = 0;

	if (unlikely(nss_ctl_redirect == 0)) {
	return NSS_TX_FAILURE_NOT_ENABLED;
	}

	if (unlikely(skb->vlan_tci)) {
	return NSS_TX_FAILURE_NOT_SUPPORTED;
	}

	if (!nss_virt_if_verify_if_num(if_num)) {
	nss_warning("%px: bad interface number %d\n", nss_ctx, if_num);
	return NSS_TX_FAILURE_BAD_PARAM;
	}

	nss_trace("%px: Virtual Rx packet, if_num:%d, skb:%px", nss_ctx, if_num, skb);

	/*
	* Sanity check the SKB to ensure that it's suitable for us
	*/
	if (unlikely(skb->len <= ETH_HLEN)) {
	nss_warning("%px: Virtual Rx packet: %px too short", nss_ctx, skb);
	return NSS_TX_FAILURE_TOO_SHORT;
	}

	/*
	* set skb queue mapping
	*/
	cpu = get_cpu();
	put_cpu();
	skb_set_queue_mapping(skb, cpu);

	return nss_core_send_packet(nss_ctx, skb, if_num, H2N_BIT_FLAG_VIRTUAL_BUFFER \|
	H2N_BIT_FLAG_BUFFER_REUSABLE);
	}
	EXPORT_SYMBOL(nss_virt_if_tx_buf);

	/*
	* nss_virt_if_tx_msg()
	*/
	nss_tx_status_t nss_virt_if_tx_msg(struct nss_ctx_instance nss_ctx, struct nss_virt_if_msg nvim)
	{
	struct nss_cmn_msg *ncm = &nvim->cm;

	/*
	* Sanity check the message
	*/
	if (!nss_virt_if_verify_if_num(ncm->interface)) {
	nss_warning("%px: tx request for another interface: %d", nss_ctx, ncm->interface);
	return NSS_TX_FAILURE;
	}

	if (ncm->type > NSS_VIRT_IF_MAX_MSG_TYPES) {
	nss_warning("%px: message type out of range: %d", nss_ctx, ncm->type);
	return NSS_TX_FAILURE;
	}

	return nss_core_send_cmd(nss_ctx, nvim, sizeof(*nvim), NSS_NBUF_PAYLOAD_SIZE);
	}
	EXPORT_SYMBOL(nss_virt_if_tx_msg);

	/*
	* nss_virt_if_xmit_callback_register()
	* Register virtual interface xmit callback.
	*/
	void nss_virt_if_xmit_callback_register(struct nss_virt_if_handle *handle,
	nss_virt_if_xmit_callback_t cb)
	{
	struct nss_ctx_instance *nss_ctx;
	struct nss_subsystem_dataplane_register *reg;

	if (!handle) {
	nss_warning("handle is NULL\n");
	return;
	}

	nss_ctx = handle->nss_ctx;
	NSS_VERIFY_CTX_MAGIC(nss_ctx);

	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
	nss_warning("if_num is invalid\n");
	return;
	}

	reg = &nss_ctx->subsys_dp_register[handle->if_num_n2h];
	reg->xmit_cb = cb;
	}
	EXPORT_SYMBOL(nss_virt_if_xmit_callback_register);

	/*
	* nss_virt_if_xmit_callback_unregister()
	* Unregister virtual interface xmit callback.
	*/
	void nss_virt_if_xmit_callback_unregister(struct nss_virt_if_handle *handle)
	{
	struct nss_ctx_instance *nss_ctx;
	struct nss_subsystem_dataplane_register *reg;

	if (!handle) {
	nss_warning("handle is NULL\n");
	return;
	}

	nss_ctx = handle->nss_ctx;
	NSS_VERIFY_CTX_MAGIC(nss_ctx);

	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
	nss_warning("if_num is invalid\n");
	return;
	}

	reg = &nss_ctx->subsys_dp_register[handle->if_num_n2h];
	reg->xmit_cb = NULL;
	}
	EXPORT_SYMBOL(nss_virt_if_xmit_callback_unregister);

	/*
	* nss_virt_if_register()
	*/
	void nss_virt_if_register(struct nss_virt_if_handle *handle,
	nss_virt_if_data_callback_t data_callback,
	struct net_device *netdev)
	{
	struct nss_ctx_instance *nss_ctx;
	int32_t if_num;
	uint32_t status;

	if (!handle) {
	nss_warning("handle is NULL\n");
	return;
	}

	nss_ctx = handle->nss_ctx;
	NSS_VERIFY_CTX_MAGIC(nss_ctx);

	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
	nss_warning("if_num is invalid\n");
	return;
	}

	if_num = handle->if_num_n2h;

	nss_core_register_subsys_dp(nss_ctx, if_num, data_callback, NULL, NULL, netdev, (uint32_t)netdev->features);
	status = nss_core_unregister_msg_handler(nss_ctx, if_num);
	if (status != NSS_CORE_STATUS_SUCCESS) {
	nss_warning("%px: unable to unregister event handler for interface(%u)", nss_ctx, if_num);
	return;
	}
	}
	EXPORT_SYMBOL(nss_virt_if_register);

	/*
	* nss_virt_if_unregister()
	*/
	void nss_virt_if_unregister(struct nss_virt_if_handle *handle)
	{
	struct nss_ctx_instance *nss_ctx;
	int32_t if_num;
	uint32_t status;

	if (!handle) {
	nss_warning("handle is NULL\n");
	return;
	}

	nss_ctx = handle->nss_ctx;
	NSS_VERIFY_CTX_MAGIC(nss_ctx);

	if (!nss_virt_if_verify_if_num(handle->if_num_n2h)) {
	nss_warning("if_num is invalid\n");
	return;
	}

	if_num = handle->if_num_n2h;

	nss_core_unregister_subsys_dp(nss_ctx, if_num);

	status = nss_core_unregister_msg_handler(nss_ctx, if_num);
	if (status != NSS_CORE_STATUS_SUCCESS) {
	nss_warning("%px: unable to unregister event handler for interface(%u)", nss_ctx, if_num);
	return;
	}
	}
	EXPORT_SYMBOL(nss_virt_if_unregister);

	/*
	* nss_virt_if_get_interface_num()
	* Get interface number for a virtual interface
	*/
	int32_t nss_virt_if_get_interface_num(struct nss_virt_if_handle *handle)
	{
	if (!handle) {
	nss_warning("virt_if handle is NULL\n");
	return -1;
	}

	/*
	* Return if_num_n2h whose datapath type is 0.
	*/
	return handle->if_num_n2h;
	}
	EXPORT_SYMBOL(nss_virt_if_get_interface_num);