qca-nss-clients/nss_connmgr_tun6rd.c - manifest_repos/sdk - Git at Google

 /*
  **************************************************************************
  * Copyright (c) 2014, 2016-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_tun6rd.c
  *
  * This file is the NSS 6rd tunnel module
  * ------------------------REVISION HISTORY-----------------------------
  * Qualcomm Atheros         15/sep/2013              Created
  */

 #include <linux/version.h>
 #include <linux/types.h>
 #include <linux/ip.h>
 #include <linux/of.h>
 #include <linux/tcp.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <net/ipv6.h>
 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,9,0))
 #include <net/ipip.h>
 #else
 #include <net/ip_tunnels.h>
 #endif
 #include <linux/if_arp.h>
 #include <nss_api_if.h>
 #include <nss_dynamic_interface.h>

 /*
  * NSS tun6rd debug macros
  */
 #if (NSS_TUN6RD_DEBUG_LEVEL < 1)
 #define nss_tun6rd_assert(fmt, args...)
 #else
 #define nss_tun6rd_assert(c) if (!(c)) { BUG_ON(!(c)); }
 #endif

 #if defined(CONFIG_DYNAMIC_DEBUG)
 /*
  * Compile messages for dynamic enable/disable
  */
 #define nss_tun6rd_warning(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define nss_tun6rd_info(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define nss_tun6rd_trace(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #else

 /*
  * Statically compile messages at different levels
  */
 #if (NSS_TUN6RD_DEBUG_LEVEL < 2)
 #define nss_tun6rd_warning(s, ...)
 #else
 #define nss_tun6rd_warning(s, ...) pr_warn("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif

 #if (NSS_TUN6RD_DEBUG_LEVEL < 3)
 #define nss_tun6rd_info(s, ...)
 #else
 #define nss_tun6rd_info(s, ...)   pr_notice("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif

 #if (NSS_TUN6RD_DEBUG_LEVEL < 4)
 #define nss_tun6rd_trace(s, ...)
 #else
 #define nss_tun6rd_trace(s, ...)  pr_info("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif
 #endif

 /*
  * 6rd tunnel stats
  */
 struct nss_tun6rd_stats {
 	uint32_t rx_packets;	/* Number of received packets */
 	uint32_t rx_bytes;	/* Number of received bytes */
 	uint32_t tx_packets;	/* Number of transmitted packets */
 	uint32_t tx_bytes;	/* Number of transmitted bytes */
 };

 /*
  * nss_tun6rd_update_dev_stats
  *	Update the Dev stats received from NetAp
  */
 static void nss_tun6rd_update_dev_stats(struct net_device *dev,
 					struct nss_tun6rd_sync_stats_msg *sync_stats)
 {
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 	struct pcpu_sw_netstats stats;

 	u64_stats_init(&stats.syncp);
 	u64_stats_update_begin(&stats.syncp);
 	stats.rx_packets = sync_stats->node_stats.rx_packets;
 	stats.rx_bytes = sync_stats->node_stats.rx_bytes;
 	stats.tx_packets = sync_stats->node_stats.tx_packets;
 	stats.tx_bytes = sync_stats->node_stats.tx_bytes;
 	u64_stats_update_end(&stats.syncp);
 #else
 	struct nss_tun6rd_stats stats;

 	stats.rx_packets = sync_stats->node_stats.rx_packets;
 	stats.rx_bytes = sync_stats->node_stats.rx_bytes;
 	stats.tx_packets = sync_stats->node_stats.tx_packets;
 	stats.tx_bytes = sync_stats->node_stats.tx_bytes;
 #endif

 	ipip6_update_offload_stats(dev, (void *)&stats);
 }

 /*
  * nss_tun6rd_event_receive()
  *	Event Callback to receive events from NSS
  */
 static void nss_tun6rd_event_receive(void *if_ctx, struct nss_tun6rd_msg *tnlmsg)
 {
 	struct net_device *netdev = if_ctx;

 	switch (tnlmsg->cm.type) {
 	case NSS_TUN6RD_RX_STATS_SYNC:
 		nss_tun6rd_update_dev_stats(netdev, (struct nss_tun6rd_sync_stats_msg *)&tnlmsg->msg.stats);
 		break;

 	default:
 		nss_tun6rd_info("Unknown Event from NSS\n");
 		break;
 	}
 }

 /*
  * nss_tun6rd_exception()
  *	Exception handler registered to NSS driver
  */
 static void nss_tun6rd_exception(struct net_device *dev, struct sk_buff *skb, __attribute__((unused)) struct napi_struct *napi)
 {
 	const struct iphdr *iph;

 	skb->dev = dev;
 	nss_tun6rd_info("received - %d bytes name %s ver %x\n",
 			skb->len,dev->name,skb->data[0]);

 	iph = (const struct iphdr *)skb->data;

 	/*
 	 * Packet after Decap/Encap Did not find the Rule.
 	 */
 	if (iph->version != 4) {
 		skb->protocol = htons(ETH_P_IPV6);
 	} else {
 		if (iph->protocol == IPPROTO_IPV6) {
 			skb_pull(skb, sizeof(struct iphdr));
 			skb->protocol = htons(ETH_P_IPV6);
 			skb_reset_network_header(skb);
 			skb->pkt_type = PACKET_HOST;
 			skb->ip_summed = CHECKSUM_NONE;
 			dev_queue_xmit(skb);
 			return;
 		}
 		skb->protocol = htons(ETH_P_IP);
 	}

 	skb_reset_network_header(skb);
 	skb->pkt_type = PACKET_HOST;
 	skb->skb_iif = dev->ifindex;
 	skb->ip_summed = CHECKSUM_NONE;
 	netif_receive_skb(skb);
 }

 /*
  * nss_tun6rd_dev_up()
  *	6RD Tunnel device i/f up handler
  */
 static int nss_tun6rd_dev_up(struct net_device *netdev)
 {
 	struct ip_tunnel *tunnel;
 	struct ip_tunnel_6rd_parm *ip6rd;
 	const struct iphdr  *tiph;
 	struct nss_tun6rd_msg msg_tunnel;
 	struct nss_tun6rd_attach_tunnel_msg *cfg_tunnel;
 	int32_t outer_if;
 	int32_t inner_if;
 	nss_tx_status_t status;
 	struct nss_ctx_instance *nss_ctx;
 	uint32_t features = 0; /* features denote the skb types supported by this interface */

 	/*
 	 * Validate netdev for ipv6-in-ipv4  Tunnel
 	 */
 	if (netdev->type != ARPHRD_SIT) {
 		return NOTIFY_DONE;
 	}

 	tunnel = (struct ip_tunnel *)netdev_priv(netdev);
 	ip6rd =  &tunnel->ip6rd;

 	/*
 	 * Valid 6rd Tunnel Check
 	 * 1. 6rd Prefix len should be non zero
 	 * 2. Relay prefix length should not be greater then 32
 	 * 3. To allow for stateless address auto-configuration on the CE LAN side,
 	 *    6rd delegated prefix SHOULD be /64 or shorter.
 	 */
 	if ((ip6rd->prefixlen == 0 )
 			|| (ip6rd->relay_prefixlen > 32)
 			|| (ip6rd->prefixlen
 				+ (32 - ip6rd->relay_prefixlen) > 64)) {

 		nss_tun6rd_warning("%px: Invalid 6rd argument prefix len %d relayprefix len %d\n",
 				netdev, ip6rd->prefixlen, ip6rd->relay_prefixlen);
 		return NOTIFY_DONE;
 	}

 	nss_tun6rd_info("%px: Valid 6rd Tunnel Prefix %x %x %x %x\n Prefix len %d relay_prefix %d relay_prefixlen %d\n",
 			netdev,
 			ip6rd->prefix.s6_addr32[0],ip6rd->prefix.s6_addr32[1],
 			ip6rd->prefix.s6_addr32[2],ip6rd->prefix.s6_addr32[3],
 			ip6rd->prefixlen, ip6rd->relay_prefix,
 			ip6rd->relay_prefixlen);

 	/*
 	 * Find the Tunnel device IP header info
 	 */
 	tiph = &tunnel->parms.iph ;
 	nss_tun6rd_trace("%px: Tunnel Param srcaddr %x daddr %x ttl %d tos %x\n",
 			netdev, tiph->saddr, tiph->daddr, tiph->ttl, tiph->tos);

 	if (tiph->saddr == 0) {
 		nss_tun6rd_warning("%px: Tunnel src address not configured %x\n",
 				netdev, tiph->saddr);
 		return NOTIFY_DONE;
 	}

 	outer_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
 	if (-1 == outer_if) {
 		nss_tun6rd_warning("%px: Request outer interface number failed\n", netdev);
 		goto outer_fail;
 	}

 	if (!nss_is_dynamic_interface(outer_if)) {
 		nss_tun6rd_warning("%px: Invalid NSS dynamic I/F number %d\n", netdev, outer_if);
 		goto outer_fail;
 	}

 	inner_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
 	if (-1 == inner_if) {
 		nss_tun6rd_warning("%px: Request inner interface number failed\n", netdev);
 		goto inner_fail;
 	}

 	if (!nss_is_dynamic_interface(inner_if)) {
 		nss_tun6rd_warning("%px: Invalid NSS dynamic I/F number %d\n", netdev, inner_if);
 		goto inner_fail;
 	}

 	/*
 	 * Register 6rd tunnel's inner interface with NSS
 	 */
 	nss_ctx = nss_register_tun6rd_if(inner_if,
 				NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER,
 				nss_tun6rd_exception,
 				nss_tun6rd_event_receive,
 				netdev,
 				features);
 	if (!nss_ctx) {
 		nss_tun6rd_trace("%px: nss_register_tun6rd_if failed for inner interface\n", netdev);
 		goto register_inner_if_fail;
 	}

 	/*
 	 * Register 6rd tunnel's outer interface with NSS
 	 */
 	nss_ctx = nss_register_tun6rd_if(outer_if,
 				NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER,
 				nss_tun6rd_exception,
 				nss_tun6rd_event_receive,
 				netdev,
 				features);
 	if (!nss_ctx) {
 		nss_tun6rd_trace("%px: nss_register_tun6rd_if failed for outer interface\n", netdev);
 		goto register_outer_if_fail;
 	}

 	/*
 	 * Prepare The Tunnel configuration parameter to send to nss
 	 */
 	memset(&msg_tunnel, 0, sizeof(struct nss_tun6rd_msg));
 	cfg_tunnel = &msg_tunnel.msg.tunnel;
 	cfg_tunnel->saddr = ntohl(tiph->saddr);
 	cfg_tunnel->daddr = ntohl(tiph->daddr);
 	cfg_tunnel->ttl = tiph->ttl;
 	cfg_tunnel->tos = tiph->tos;
 	cfg_tunnel->sibling_if_num = outer_if;

 	nss_tun6rd_trace("%px: Sending 6rd tunnel i/f up command to NSS %px\n",
 			netdev, nss_ctx);

 	/*
 	 * Send 6rd Tunnel UP command to NSS
 	 */
 	nss_tun6rd_msg_init(&msg_tunnel, inner_if, NSS_TUN6RD_ATTACH_PNODE,
 			sizeof(struct nss_tun6rd_attach_tunnel_msg), NULL, NULL);

 	status = nss_tun6rd_tx(nss_ctx, &msg_tunnel);
 	if (status != NSS_TX_SUCCESS) {
 		nss_tun6rd_warning("%px: Tunnel up command error %d\n", netdev, status);
 		goto tunnel_up_fail;
 	}

 	return NOTIFY_OK;

 tunnel_up_fail:
 	nss_unregister_tun6rd_if(outer_if);

 register_outer_if_fail:
 	nss_unregister_tun6rd_if(inner_if);

 register_inner_if_fail:
 	status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
 	if (status != NSS_TX_SUCCESS) {
 		nss_tun6rd_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", netdev, inner_if);
 	}

 inner_fail:
 	status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
 	if (status != NSS_TX_SUCCESS) {
 		nss_tun6rd_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", netdev, outer_if);
 	}

 outer_fail:
 	return NOTIFY_DONE;
 }

 /*
  * nss_tun6rd_dev_down()
  *	6RD Tunnel device i/f down handler
  */
 static int nss_tun6rd_dev_down(struct net_device *netdev)
 {
 	struct ip_tunnel *tunnel;
 	struct ip_tunnel_6rd_parm *ip6rd;
 	int32_t outer_if;
 	int32_t inner_if;
 	nss_tx_status_t status;

 	/*
 	 * Validate netdev for ipv6-in-ipv4  Tunnel
 	 */
 	if (netdev->type != ARPHRD_SIT) {
 		return NOTIFY_DONE;
 	}

 	tunnel = (struct ip_tunnel *)netdev_priv(netdev);
 	ip6rd =  &tunnel->ip6rd;

 	/*
 	 * Valid 6rd Tunnel Check
 	 */
 	if ((ip6rd->prefixlen == 0 )
 			|| (ip6rd->relay_prefixlen > 32 )
 			|| (ip6rd->prefixlen
 				+ (32 - ip6rd->relay_prefixlen) > 64)) {

 		nss_tun6rd_warning("%px: Invalid 6rd argument prefix len %d relayprefix len %d\n",
 				netdev, ip6rd->prefixlen, ip6rd->relay_prefixlen);
 		return NOTIFY_DONE;
 	}

 	/*
 	 * Check if tunnel 6rd outer is registered ?
 	 */
 	outer_if = nss_cmn_get_interface_number_by_dev_and_type(netdev, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
 	if (outer_if < 0) {
 		nss_tun6rd_warning("%px: Net device is not registered\n", netdev);
 		return NOTIFY_DONE;
 	}

 	/*
 	 * Un-Register 6rd tunnel's outer interface with NSS
 	 */
 	nss_unregister_tun6rd_if(outer_if);
 	status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
 	if (status != NSS_TX_SUCCESS) {
 		nss_tun6rd_warning("%px: Dealloc outer interface failed\n", netdev);
 		return NOTIFY_DONE;
 	}

 	/*
 	 * Check if tunnel 6rd inner is registered ?
 	 */
 	inner_if = nss_cmn_get_interface_number_by_dev_and_type(netdev, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
 	if (inner_if < 0) {
 		nss_tun6rd_warning("%px: Net device is not registered\n", netdev);
 		return NOTIFY_DONE;
 	}

 	/*
 	 * Un-Register 6rd tunnel's inner interface with NSS
 	 */
 	nss_unregister_tun6rd_if(inner_if);
 	status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
 	if (status != NSS_TX_SUCCESS) {
 		nss_tun6rd_warning("%px: Dealloc inner interface failed\n", netdev);
 		return NOTIFY_DONE;
 	}

 	return NOTIFY_OK;
 }

 /*
  * nss_tun6rd_dev_event()
  *	Net device notifier for 6rd module
  */
 static int nss_tun6rd_dev_event(struct notifier_block  *nb,
 		unsigned long event, void  *dev)
 {
 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,10,0))
 	struct net_device *netdev = (struct net_device *)dev;
 #else
 	struct net_device *netdev = netdev_notifier_info_to_dev(dev);
 #endif

 	switch (event) {
 	case NETDEV_UP:
 		nss_tun6rd_trace("NETDEV_UP: event %lu name %s\n", event, netdev->name);
 		return nss_tun6rd_dev_up(netdev);

 	case NETDEV_DOWN:
 		nss_tun6rd_trace("NETDEV_DOWN: event %lu name %s\n", event, netdev->name);
 		return nss_tun6rd_dev_down(netdev);

 	default:
 		nss_tun6rd_trace("Unhandled notifier event %lu name %s\n",event, netdev->name);
 		break;
 	}

 	return NOTIFY_DONE;
 }

 /*
  * Linux Net device Notifier
  */
 struct notifier_block nss_tun6rd_notifier = {
 	.notifier_call = nss_tun6rd_dev_event,
 };

 /*
  * nss_tun6rd_init_module()
  *	Tunnel 6rd module init function
  */
 int __init nss_tun6rd_init_module(void)
 {
 #ifdef CONFIG_OF
 	/*
 	 * If the node is not compatible, don't do anything.
 	 */
 	if (!of_find_node_by_name(NULL, "nss-common")) {
 		return 0;
 	}
 #endif
 	nss_tun6rd_info("module (platform - IPQ806x , %s) loaded\n",
 			NSS_CLIENT_BUILD_ID);

 	register_netdevice_notifier(&nss_tun6rd_notifier);
 	nss_tun6rd_trace("Netdev Notifier registered\n");

 	return 0;
 }

 /*
  * nss_tun6rd_exit_module()
  *	Tunnel 6rd module exit function
  */
 void __exit nss_tun6rd_exit_module(void)
 {
 #ifdef CONFIG_OF
 	/*
 	 * If the node is not compatible, don't do anything.
 	 */
 	if (!of_find_node_by_name(NULL, "nss-common")) {
 		return;
 	}
 #endif
 	unregister_netdevice_notifier(&nss_tun6rd_notifier);
 	nss_tun6rd_info("module unloaded\n");
 }

 module_init(nss_tun6rd_init_module);
 module_exit(nss_tun6rd_exit_module);

 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("NSS tun6rd offload manager");
	/*
	**************************************************************************
	* Copyright (c) 2014, 2016-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_tun6rd.c
	*
	* This file is the NSS 6rd tunnel module
	* ------------------------REVISION HISTORY-----------------------------
	* Qualcomm Atheros 15/sep/2013 Created
	*/

	#include <linux/version.h>
	#include <linux/types.h>
	#include <linux/ip.h>
	#include <linux/of.h>
	#include <linux/tcp.h>
	#include <linux/module.h>
	#include <linux/skbuff.h>
	#include <net/ipv6.h>
	#if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,9,0))
	#include <net/ipip.h>
	#else
	#include <net/ip_tunnels.h>
	#endif
	#include <linux/if_arp.h>
	#include <nss_api_if.h>
	#include <nss_dynamic_interface.h>

	/*
	* NSS tun6rd debug macros
	*/
	#if (NSS_TUN6RD_DEBUG_LEVEL < 1)
	#define nss_tun6rd_assert(fmt, args...)
	#else
	#define nss_tun6rd_assert(c) if (!(c)) { BUG_ON(!(c)); }
	#endif

	#if defined(CONFIG_DYNAMIC_DEBUG)
	/*
	* Compile messages for dynamic enable/disable
	*/
	#define nss_tun6rd_warning(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define nss_tun6rd_info(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define nss_tun6rd_trace(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#else

	/*
	* Statically compile messages at different levels
	*/
	#if (NSS_TUN6RD_DEBUG_LEVEL < 2)
	#define nss_tun6rd_warning(s, ...)
	#else
	#define nss_tun6rd_warning(s, ...) pr_warn("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif

	#if (NSS_TUN6RD_DEBUG_LEVEL < 3)
	#define nss_tun6rd_info(s, ...)
	#else
	#define nss_tun6rd_info(s, ...) pr_notice("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif

	#if (NSS_TUN6RD_DEBUG_LEVEL < 4)
	#define nss_tun6rd_trace(s, ...)
	#else
	#define nss_tun6rd_trace(s, ...) pr_info("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif
	#endif

	/*
	* 6rd tunnel stats
	*/
	struct nss_tun6rd_stats {
	uint32_t rx_packets; /* Number of received packets */
	uint32_t rx_bytes; /* Number of received bytes */
	uint32_t tx_packets; /* Number of transmitted packets */
	uint32_t tx_bytes; /* Number of transmitted bytes */
	};

	/*
	* nss_tun6rd_update_dev_stats
	* Update the Dev stats received from NetAp
	*/
	static void nss_tun6rd_update_dev_stats(struct net_device *dev,
	struct nss_tun6rd_sync_stats_msg *sync_stats)
	{
	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
	struct pcpu_sw_netstats stats;

	u64_stats_init(&stats.syncp);
	u64_stats_update_begin(&stats.syncp);
	stats.rx_packets = sync_stats->node_stats.rx_packets;
	stats.rx_bytes = sync_stats->node_stats.rx_bytes;
	stats.tx_packets = sync_stats->node_stats.tx_packets;
	stats.tx_bytes = sync_stats->node_stats.tx_bytes;
	u64_stats_update_end(&stats.syncp);
	#else
	struct nss_tun6rd_stats stats;

	stats.rx_packets = sync_stats->node_stats.rx_packets;
	stats.rx_bytes = sync_stats->node_stats.rx_bytes;
	stats.tx_packets = sync_stats->node_stats.tx_packets;
	stats.tx_bytes = sync_stats->node_stats.tx_bytes;
	#endif

	ipip6_update_offload_stats(dev, (void *)&stats);
	}

	/*
	* nss_tun6rd_event_receive()
	* Event Callback to receive events from NSS
	*/
	static void nss_tun6rd_event_receive(void if_ctx, struct nss_tun6rd_msg tnlmsg)
	{
	struct net_device *netdev = if_ctx;

	switch (tnlmsg->cm.type) {
	case NSS_TUN6RD_RX_STATS_SYNC:
	nss_tun6rd_update_dev_stats(netdev, (struct nss_tun6rd_sync_stats_msg *)&tnlmsg->msg.stats);
	break;

	default:
	nss_tun6rd_info("Unknown Event from NSS\n");
	break;
	}
	}

	/*
	* nss_tun6rd_exception()
	* Exception handler registered to NSS driver
	*/
	static void nss_tun6rd_exception(struct net_device dev, struct sk_buff skb, __attribute__((unused)) struct napi_struct *napi)
	{
	const struct iphdr *iph;

	skb->dev = dev;
	nss_tun6rd_info("received - %d bytes name %s ver %x\n",
	skb->len,dev->name,skb->data[0]);

	iph = (const struct iphdr *)skb->data;

	/*
	* Packet after Decap/Encap Did not find the Rule.
	*/
	if (iph->version != 4) {
	skb->protocol = htons(ETH_P_IPV6);
	} else {
	if (iph->protocol == IPPROTO_IPV6) {
	skb_pull(skb, sizeof(struct iphdr));
	skb->protocol = htons(ETH_P_IPV6);
	skb_reset_network_header(skb);
	skb->pkt_type = PACKET_HOST;
	skb->ip_summed = CHECKSUM_NONE;
	dev_queue_xmit(skb);
	return;
	}
	skb->protocol = htons(ETH_P_IP);
	}

	skb_reset_network_header(skb);
	skb->pkt_type = PACKET_HOST;
	skb->skb_iif = dev->ifindex;
	skb->ip_summed = CHECKSUM_NONE;
	netif_receive_skb(skb);
	}

	/*
	* nss_tun6rd_dev_up()
	* 6RD Tunnel device i/f up handler
	*/
	static int nss_tun6rd_dev_up(struct net_device *netdev)
	{
	struct ip_tunnel *tunnel;
	struct ip_tunnel_6rd_parm *ip6rd;
	const struct iphdr *tiph;
	struct nss_tun6rd_msg msg_tunnel;
	struct nss_tun6rd_attach_tunnel_msg *cfg_tunnel;
	int32_t outer_if;
	int32_t inner_if;
	nss_tx_status_t status;
	struct nss_ctx_instance *nss_ctx;
	uint32_t features = 0; /* features denote the skb types supported by this interface */

	/*
	* Validate netdev for ipv6-in-ipv4 Tunnel
	*/
	if (netdev->type != ARPHRD_SIT) {
	return NOTIFY_DONE;
	}

	tunnel = (struct ip_tunnel *)netdev_priv(netdev);
	ip6rd = &tunnel->ip6rd;

	/*
	* Valid 6rd Tunnel Check
	* 1. 6rd Prefix len should be non zero
	* 2. Relay prefix length should not be greater then 32
	* 3. To allow for stateless address auto-configuration on the CE LAN side,
	* 6rd delegated prefix SHOULD be /64 or shorter.
	*/
	if ((ip6rd->prefixlen == 0 )
	\|\| (ip6rd->relay_prefixlen > 32)
	\|\| (ip6rd->prefixlen
	+ (32 - ip6rd->relay_prefixlen) > 64)) {

	nss_tun6rd_warning("%px: Invalid 6rd argument prefix len %d relayprefix len %d\n",
	netdev, ip6rd->prefixlen, ip6rd->relay_prefixlen);
	return NOTIFY_DONE;
	}

	nss_tun6rd_info("%px: Valid 6rd Tunnel Prefix %x %x %x %x\n Prefix len %d relay_prefix %d relay_prefixlen %d\n",
	netdev,
	ip6rd->prefix.s6_addr32[0],ip6rd->prefix.s6_addr32[1],
	ip6rd->prefix.s6_addr32[2],ip6rd->prefix.s6_addr32[3],
	ip6rd->prefixlen, ip6rd->relay_prefix,
	ip6rd->relay_prefixlen);

	/*
	* Find the Tunnel device IP header info
	*/
	tiph = &tunnel->parms.iph ;
	nss_tun6rd_trace("%px: Tunnel Param srcaddr %x daddr %x ttl %d tos %x\n",
	netdev, tiph->saddr, tiph->daddr, tiph->ttl, tiph->tos);

	if (tiph->saddr == 0) {
	nss_tun6rd_warning("%px: Tunnel src address not configured %x\n",
	netdev, tiph->saddr);
	return NOTIFY_DONE;
	}

	outer_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
	if (-1 == outer_if) {
	nss_tun6rd_warning("%px: Request outer interface number failed\n", netdev);
	goto outer_fail;
	}

	if (!nss_is_dynamic_interface(outer_if)) {
	nss_tun6rd_warning("%px: Invalid NSS dynamic I/F number %d\n", netdev, outer_if);
	goto outer_fail;
	}

	inner_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
	if (-1 == inner_if) {
	nss_tun6rd_warning("%px: Request inner interface number failed\n", netdev);
	goto inner_fail;
	}

	if (!nss_is_dynamic_interface(inner_if)) {
	nss_tun6rd_warning("%px: Invalid NSS dynamic I/F number %d\n", netdev, inner_if);
	goto inner_fail;
	}

	/*
	* Register 6rd tunnel's inner interface with NSS
	*/
	nss_ctx = nss_register_tun6rd_if(inner_if,
	NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER,
	nss_tun6rd_exception,
	nss_tun6rd_event_receive,
	netdev,
	features);
	if (!nss_ctx) {
	nss_tun6rd_trace("%px: nss_register_tun6rd_if failed for inner interface\n", netdev);
	goto register_inner_if_fail;
	}

	/*
	* Register 6rd tunnel's outer interface with NSS
	*/
	nss_ctx = nss_register_tun6rd_if(outer_if,
	NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER,
	nss_tun6rd_exception,
	nss_tun6rd_event_receive,
	netdev,
	features);
	if (!nss_ctx) {
	nss_tun6rd_trace("%px: nss_register_tun6rd_if failed for outer interface\n", netdev);
	goto register_outer_if_fail;
	}

	/*
	* Prepare The Tunnel configuration parameter to send to nss
	*/
	memset(&msg_tunnel, 0, sizeof(struct nss_tun6rd_msg));
	cfg_tunnel = &msg_tunnel.msg.tunnel;
	cfg_tunnel->saddr = ntohl(tiph->saddr);
	cfg_tunnel->daddr = ntohl(tiph->daddr);
	cfg_tunnel->ttl = tiph->ttl;
	cfg_tunnel->tos = tiph->tos;
	cfg_tunnel->sibling_if_num = outer_if;

	nss_tun6rd_trace("%px: Sending 6rd tunnel i/f up command to NSS %px\n",
	netdev, nss_ctx);

	/*
	* Send 6rd Tunnel UP command to NSS
	*/
	nss_tun6rd_msg_init(&msg_tunnel, inner_if, NSS_TUN6RD_ATTACH_PNODE,
	sizeof(struct nss_tun6rd_attach_tunnel_msg), NULL, NULL);

	status = nss_tun6rd_tx(nss_ctx, &msg_tunnel);
	if (status != NSS_TX_SUCCESS) {
	nss_tun6rd_warning("%px: Tunnel up command error %d\n", netdev, status);
	goto tunnel_up_fail;
	}

	return NOTIFY_OK;

	tunnel_up_fail:
	nss_unregister_tun6rd_if(outer_if);

	register_outer_if_fail:
	nss_unregister_tun6rd_if(inner_if);

	register_inner_if_fail:
	status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
	if (status != NSS_TX_SUCCESS) {
	nss_tun6rd_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", netdev, inner_if);
	}

	inner_fail:
	status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
	if (status != NSS_TX_SUCCESS) {
	nss_tun6rd_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", netdev, outer_if);
	}

	outer_fail:
	return NOTIFY_DONE;
	}

	/*
	* nss_tun6rd_dev_down()
	* 6RD Tunnel device i/f down handler
	*/
	static int nss_tun6rd_dev_down(struct net_device *netdev)
	{
	struct ip_tunnel *tunnel;
	struct ip_tunnel_6rd_parm *ip6rd;
	int32_t outer_if;
	int32_t inner_if;
	nss_tx_status_t status;

	/*
	* Validate netdev for ipv6-in-ipv4 Tunnel
	*/
	if (netdev->type != ARPHRD_SIT) {
	return NOTIFY_DONE;
	}

	tunnel = (struct ip_tunnel *)netdev_priv(netdev);
	ip6rd = &tunnel->ip6rd;

	/*
	* Valid 6rd Tunnel Check
	*/
	if ((ip6rd->prefixlen == 0 )
	\|\| (ip6rd->relay_prefixlen > 32 )
	\|\| (ip6rd->prefixlen
	+ (32 - ip6rd->relay_prefixlen) > 64)) {

	nss_tun6rd_warning("%px: Invalid 6rd argument prefix len %d relayprefix len %d\n",
	netdev, ip6rd->prefixlen, ip6rd->relay_prefixlen);
	return NOTIFY_DONE;
	}

	/*
	* Check if tunnel 6rd outer is registered ?
	*/
	outer_if = nss_cmn_get_interface_number_by_dev_and_type(netdev, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
	if (outer_if < 0) {
	nss_tun6rd_warning("%px: Net device is not registered\n", netdev);
	return NOTIFY_DONE;
	}

	/*
	* Un-Register 6rd tunnel's outer interface with NSS
	*/
	nss_unregister_tun6rd_if(outer_if);
	status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_OUTER);
	if (status != NSS_TX_SUCCESS) {
	nss_tun6rd_warning("%px: Dealloc outer interface failed\n", netdev);
	return NOTIFY_DONE;
	}

	/*
	* Check if tunnel 6rd inner is registered ?
	*/
	inner_if = nss_cmn_get_interface_number_by_dev_and_type(netdev, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
	if (inner_if < 0) {
	nss_tun6rd_warning("%px: Net device is not registered\n", netdev);
	return NOTIFY_DONE;
	}

	/*
	* Un-Register 6rd tunnel's inner interface with NSS
	*/
	nss_unregister_tun6rd_if(inner_if);
	status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_TUN6RD_INNER);
	if (status != NSS_TX_SUCCESS) {
	nss_tun6rd_warning("%px: Dealloc inner interface failed\n", netdev);
	return NOTIFY_DONE;
	}

	return NOTIFY_OK;
	}

	/*
	* nss_tun6rd_dev_event()
	* Net device notifier for 6rd module
	*/
	static int nss_tun6rd_dev_event(struct notifier_block *nb,
	unsigned long event, void *dev)
	{
	#if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,10,0))
	struct net_device netdev = (struct net_device )dev;
	#else
	struct net_device *netdev = netdev_notifier_info_to_dev(dev);
	#endif

	switch (event) {
	case NETDEV_UP:
	nss_tun6rd_trace("NETDEV_UP: event %lu name %s\n", event, netdev->name);
	return nss_tun6rd_dev_up(netdev);

	case NETDEV_DOWN:
	nss_tun6rd_trace("NETDEV_DOWN: event %lu name %s\n", event, netdev->name);
	return nss_tun6rd_dev_down(netdev);

	default:
	nss_tun6rd_trace("Unhandled notifier event %lu name %s\n",event, netdev->name);
	break;
	}

	return NOTIFY_DONE;
	}

	/*
	* Linux Net device Notifier
	*/
	struct notifier_block nss_tun6rd_notifier = {
	.notifier_call = nss_tun6rd_dev_event,
	};

	/*
	* nss_tun6rd_init_module()
	* Tunnel 6rd module init function
	*/
	int __init nss_tun6rd_init_module(void)
	{
	#ifdef CONFIG_OF
	/*
	* If the node is not compatible, don't do anything.
	*/
	if (!of_find_node_by_name(NULL, "nss-common")) {
	return 0;
	}
	#endif
	nss_tun6rd_info("module (platform - IPQ806x , %s) loaded\n",
	NSS_CLIENT_BUILD_ID);

	register_netdevice_notifier(&nss_tun6rd_notifier);
	nss_tun6rd_trace("Netdev Notifier registered\n");

	return 0;
	}

	/*
	* nss_tun6rd_exit_module()
	* Tunnel 6rd module exit function
	*/
	void __exit nss_tun6rd_exit_module(void)
	{
	#ifdef CONFIG_OF
	/*
	* If the node is not compatible, don't do anything.
	*/
	if (!of_find_node_by_name(NULL, "nss-common")) {
	return;
	}
	#endif
	unregister_netdevice_notifier(&nss_tun6rd_notifier);
	nss_tun6rd_info("module unloaded\n");
	}

	module_init(nss_tun6rd_init_module);
	module_exit(nss_tun6rd_exit_module);

	MODULE_LICENSE("Dual BSD/GPL");
	MODULE_DESCRIPTION("NSS tun6rd offload manager");